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 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include<iostream>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
#include<set>
#include<map>
#include<random>
#include<functional>
#include<utility>

typedef long long ll;

#define rep(i,n) for(int i=0; i<n; i++)
#define pb push_back
#define P pair<int, int>
#define PLI pair<ll, int>
#define PLL pair<ll, ll>
#define VI vector<int>
#define VII vector<VI>

using namespace std;


const ll INF = 1e18;

struct Range
{
	int l, r;
	ll c;
	Range(int l, int r, int c) :l(l), r(r), c(c) {}
	bool operator<(const Range &ra)const {
		if (l < ra.l) return true;
		if (l == ra.l) {
			if (c < ra.c) return true;
			if (c == ra.c) {
				return r > ra.r;
			}
		}
		return false;
	}
};

int N, M;
vector<Range> Ran;
ll cost[100005];
int main() {
	cin >> N >> M;
	//scanf("%d%d", &N, &M);
	rep(i, M) {
		int l, r, c;
		//scanf("%d%d%d", &l, &r, &c);
		cin >> l >> r >> c; 
		l--; r--;
		Ran.emplace_back(l, r, c);
	}
	sort(Ran.begin(), Ran.end());

	rep(i, N) cost[i] = INF;
	cost[0] = 0;
	priority_queue<PLL, vector<PLL>, greater<>> pq;
	pq.emplace(0, 0);
	while (!pq.empty())
	{
		PLL now = pq.top(); pq.pop();
		ll co = now.first, v = now.second;
		if (cost[v] < co) continue;
		auto it1 = lower_bound(Ran.begin(), Ran.end(), Range(v, 0, 0));
		if (it1 == Ran.end()) continue;
		Range nxt = *it1;
		int to = v + 1;
		while (nxt.l == v)
		{
			int nr = nxt.r; ll nco = nxt.c;
			for (; to <= nr; to++) {
				if (cost[to] > co + nco) {
					cost[to] = co + nco;
					pq.emplace(cost[to], to);
				}
			}
			it1++;
			if (it1 == Ran.end()) break;
			nxt = *it1;
			if (nxt.r <= nr) break;
		}
	}

	ll ans = cost[N - 1];
	if (ans == INF) ans = -1;
	cout << ans << endl;
	//printf("%lld\n", ans);

	return 0;
}