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 Kotlin (1.0.0) (judge verdict: Wrong Answer)

import java.util.*

fun main(args:Array<String>) {
    val (n,m) = readLine()!!.split(" ").map { it.toInt() }
    val roadList = (1..m).map { Road(readLine()!!.split(" "))}
    val roadDic = TreeMap<Int,TreeMap<Int,Long>>()
    for(r in roadList) {
        if(!roadDic.containsKey(r.fromPos)) {
            roadDic[r.fromPos] = TreeMap()
        }
        if(roadDic[r.fromPos]!!.containsKey(r.toPos)) {
            roadDic[r.fromPos]!![r.toPos] = Math.min(roadDic[r.fromPos]!![r.toPos]!!, r.len)
        } else {
            roadDic[r.fromPos]!![r.toPos] = r.len
        }
    }
    val map = (1..n).map { Long.MAX_VALUE }.toMutableList()
    map[0] = 0
    val que = LinkedList<Int>()
    que.push(0)
    val fromKeyList = roadDic.keys.toList()
    var lastIndex = 0
    while(que.isNotEmpty()) {
        val current = que.pop()
        for(fromIndex in (lastIndex until fromKeyList.size)) {
            val fromKey = fromKeyList[fromIndex]
            if(fromKey > current) {
                break
            }
            if(roadDic[fromKey]!!.firstKey()*-1 < current) {
                lastIndex = fromIndex + 1
                continue
            }
            var min = Long.MAX_VALUE
            for(toKey in roadDic[fromKey]!!.keys) {
                val toPos = toKey * -1
                if(toPos < current) {
                    break
                }
                val len = roadDic[fromKey]!![toKey]!! + map[current]
                if(min < len) {
                    break
                }
                min = len
                if(map[toPos] > len) {
                    map[toPos] = len
                    que.push(toPos)
                }
            }
        }
    }
    if(map.last() == Long.MAX_VALUE) {
        println(-1)
    } else {
        println(map.last())
    }
}

class Road(val inpt:List<String>) {
    val fromPos = inpt[0].toInt() - 1
    val toPos = (inpt[1].toInt() - 1) * -1
    val len = inpt[2].toLong()
}