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: Accepted)

use std::str::FromStr;
use std::fmt::Debug;
use std::cmp;
use std::collections::BinaryHeap;

#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}

fn main(){
    let line = read_as_vec::<usize>();

    let (n, m) = (line[0], line[1]);

    let mut edges = vec![vec![];n];

    for _ in 0..m{
        let line = read_as_vec::<usize>();
        let (l, r, c) = (line[0]-1, line[1] - 1, line[2] as i64);
        edges[l].push((r, c));
    }

    for i in 1..n{
        edges[i].push((i-1,0));
    }


    let mut heap = BinaryHeap::new();
    let mut min_paths = vec![std::i64::MAX;n];
    min_paths[0] = 0;
    heap.push((0, 0));

    while let Some((cost, u)) = heap.pop(){
        let cur_cost = -cost;
        for &(next_v, next_cost) in &edges[u]{
            if cur_cost + next_cost < min_paths[next_v]{
                min_paths[next_v] = cur_cost + next_cost;
                heap.push((-(cur_cost + next_cost), next_v));
            }
        }
    }
    if min_paths[n-1] == std::i64::MAX{
        println!("{}", -1);
    }else{
        println!("{}", min_paths[n-1]);
    }
}