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 Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::Read;

fn calc_segment_index(l: usize, r: usize, k: usize) -> Vec<usize> {
    let mut x = l + k;
    let mut y = r + k;
    let mut a = vec![];
    let mut b = vec![];
    while x < y {
        if x & 1 == 1 {
            a.push(x);
            x += 1;
        }
        if y & 1 == 1 {
            y -= 1;
            b.push(y);
        }
        x >>= 1;
        y >>= 1;
    }
    b.reverse();
    a.append(&mut b);
    a
}

fn run() {
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut it = s.trim().split_whitespace();
    let n: usize = it.next().unwrap().parse().unwrap();
    let m: usize = it.next().unwrap().parse().unwrap();
    let size = n.next_power_of_two();
    let mut graph = vec![vec![]; 3 * size + 2 * m];
    let mut up = vec![0; 2 * size];
    let mut down = vec![0; 2 * size];
    for i in 0..size {
        up[size + i] = i;
        down[size + i] = i;
    }
    for i in 1..(size + 1) {
        up[i] = size + i;
        down[i] = 2 * size + i;
    }
    for i in 1..size {
        graph[down[i]].push((down[2 * i    ], 0));
        graph[down[i]].push((down[2 * i + 1], 0));
        graph[up[2 * i    ]].push((up[i], 0));
        graph[up[2 * i + 1]].push((up[i], 0));
    }
    for i in 0..size {
        graph[i].push((up[size + i], 0));
        graph[down[size + i]].push((i, 0));
    }
    for k in 0..m {
        let l = it.next().unwrap().parse::<usize>().unwrap() - 1;
        let r = it.next().unwrap().parse::<usize>().unwrap();
        let c: i64 = it.next().unwrap().parse().unwrap();
        let s = 3 * size + k;
        let t = 3 * size + m + k;
        let a = calc_segment_index(l, r, size);
        for a in a {
            graph[up[a]].push((s, 0));
            graph[t].push((down[a], 0));
        }
        graph[s].push((t, c));
    }
    let len = graph.len();
    let mut dp = vec![std::i64::MAX; len];
    dp[0] = 0;
    let mut h = std::collections::BinaryHeap::new();
    h.push((0, 0));
    while let Some((d, v)) = h.pop() {
        let d = -d;
        if d > dp[v] {
            continue;
        }
        for &(u, c) in &graph[v] {
            let d = d + c;
            if d < dp[u] {
                dp[u] = d;
                h.push((-d, u));
            }
        }
    }
    if dp[n - 1] == std::i64::MAX {
        println!("-1");
    } else {
        println!("{}", dp[n - 1]);
    }

}

fn main() {
    run();
}