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 (GCC 9.2.1) (judge verdict: Accepted)

#include <stdio.h>

typedef struct {
	int key, id;
} data;

typedef struct {
	data obj[100001];
	int size;
} max_heap;

void push(data x, max_heap* h)
{
	int i = h->size;
	data tmp;
	h->obj[(h->size)++] = x;
	while (1) {
		if (i == 0) break;
		else if (h->obj[i].key > h->obj[(i-1)/2].key) {
			tmp = h->obj[(i-1)/2];
			h->obj[(i-1)/2] = h->obj[i];
			h->obj[i] = tmp;
			i = (i - 1) / 2;
		} else break;
	}
}

data pop(max_heap* h)
{
	int i = 0, j;
	data output = h->obj[0], tmp;
	h->obj[0] = h->obj[--(h->size)];
	while (1) {
		if (i * 2 + 1 >= h->size) break;
		else if (i * 2 + 2 >= h->size) j = i * 2 + 1;
		else if (h->obj[i*2+1].key > h->obj[i*2+2].key) j = i * 2 + 1;
		else j = i * 2 + 2;
		if (h->obj[j].key > h->obj[i].key) {
			tmp = h->obj[j];
			h->obj[j] = h->obj[i];
			h->obj[i] = tmp;
			i = j;
		} else break;
	}
	return output;
}

void BIT_update(long long BIT[], int n, int i, long long k)
{
	while (i <= n) {
		if (BIT[i] > k) BIT[i] = k;
		i += (i & -i);
	}
}

long long BIT_min(long long BIT[], int r)
{
	long long min = BIT[r];
	while (r > 0) {
		if (BIT[r] < min) min = BIT[r];
		r -= (r & -r);
	}
	return min;
}

int main()
{
	int i, N, M, L[100001], R[100001], C[100001];
	scanf("%d %d", &N, &M);
	for (i = 1; i <= M; i++) scanf("%d %d %d", &(L[i]), &(R[i]), &(C[i]));
	
	data d;
	max_heap h;
	h.size = 0;
	for (i = 1; i <= M; i++) {
		d.key = R[i];
		d.id = i;
		push(d, &h);
	}
	
	const long long sup = (long long)1 << 60;
	long long min, BIT[100001];
	for (i = 1; i <= N; i++) BIT[i] = sup;
	BIT_update(BIT, N, N, 0);
	while (h.size > 0) {
		d = pop(&h);
		min = BIT_min(BIT, R[d.id]);
		if (BIT_min(BIT, L[d.id]) > min + C[d.id]) BIT_update(BIT, N, L[d.id], min + C[d.id]);
	}

	if (BIT_min(BIT, 1) < sup) printf("%lld\n", BIT_min(BIT, 1));
	else printf("-1\n");
	fflush(stdout);
	return 0;
}