Problem:
Score : 600 points

Problem Statement

We have N points numbered 1 to N arranged in a line in this order.

Takahashi decides to make an undirected graph, using these points as the vertices.
In the beginning, the graph has no edge. Takahashi will do M operations to add edges in this graph.
The i-th operation is as follows:

The operation uses integers L_i and R_i between 1 and N (inclusive), and a positive integer C_i. For every pair of integers (s, t) such that L_i \leq s < t \leq R_i, add an edge of length C_i between Vertex s and Vertex t.

The integers L_1, ..., L_M, R_1, ..., R_M, C_1, ..., C_M are all given as input.

Takahashi wants to solve the shortest path problem in the final graph obtained. Find the length of the shortest path from Vertex 1 to Vertex N in the final graph.

Constraints

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq L_i < R_i \leq N

1 \leq C_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N M
L_1 R_1 C_1
:
L_M R_M C_M

Output

Print the length of the shortest path from Vertex 1 to Vertex N in the final graph.
If there is no shortest path, print -1 instead.

Sample Input 1

4 3
1 3 2
2 4 3
1 4 6

Sample Output 1

5

We have an edge of length 2 between Vertex 1 and Vertex 2, and an edge of length 3 between Vertex 2 and Vertex 4, so there is a path of length 5 between Vertex 1 and Vertex 4.

Sample Input 2

4 2
1 2 1
3 4 2

Sample Output 2

-1

Sample Input 3

10 7
1 5 18
3 4 8
1 3 5
4 7 10
5 9 8
6 10 5
8 10 3

Sample Output 3

28

Solution in C++14 (Clang 3.8.0) (judge verdict: Wrong Answer)



#include <cctype>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#include <deque>
#include <vector>
#include <map>
#include <set>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
typedef long long ll;

typedef set<pair<int,int> > S;

struct E {
  int l, r;
  ll c;
};
bool cmpL(const E& e1, const E& e2) {
  return e1.l < e2.l;
}

struct K {
  int l, r;
  ll c;
};
bool operator>(const K& e1, const K& e2) {
  return e1.c > e2.c;
}

E es[100000+10];
ll dist[100000+10];
const ll INF = 1e18;

int main(void) {
  int n, m;
  scanf("%d%d", &n, &m);
  REP(i, m) {
    scanf("%d%d%lld", &es[i].l, &es[i].r, &es[i].c);
    es[i].l--;
    es[i].r--;
  }
  REP(i, n) {
    dist[i] = INF;
  }
  sort(es, es + m, cmpL);
  priority_queue<K, vector<K>, greater<K> > q;
  int ii = 0;
  for(; ii < m && es[ii].l == 0; ++ii) {
    q.push((K){es[ii].l, es[ii].r, 0+es[ii].c});
  }
  dist[0] = 0;
  int iii = 1;
  while(!q.empty()) {
    K cur = q.top(); q.pop();
    if(cur.r < iii) {
      continue;
    }
    while(iii <= cur.r) {
      dist[iii] = dist[cur.l] + cur.c;
      ++iii;
    }
    for(; ii < m && es[ii].l < iii; ++ii) {
      q.push((K){es[ii].l, es[ii].r, dist[es[ii].l] + es[ii].c});
    }
  }
  cout << (dist[n-1] == INF ? -1 : dist[n-1]) << endl;
  return 0;
}