Problem:
Problem D: One-Time Path

Problem

N個の島とM本の橋がある。
N個の島にはそれぞれ1からNまでの番号が割り振られている。
M本の橋にもそれぞれ1からMまでの番号が割り振られている。

がっちょ君は現在(時刻0の時点で)、1番目の島にいる。
がっちょ君はi番目の橋を利用することにより、ai番目の島からbi番目の島へと単方向に移動することができる。

しかし、時刻0の時点では、すべての橋は潮が満ちていて海の中に沈んでしまっている。
i番目の橋は、時刻ciになると潮が引いて渡れるようになる。
そして、時刻ciを過ぎると、すぐにまた潮が満ちてi番目の橋は再び沈んでしまう。
再び沈んでしまうと、またいつ潮が引いて渡れるようになるかはわからない。
そこで、がっちょ君はそうなった橋は永遠に渡れなくなると考えるようにした。

がっちょ君は、できるだけ長い間、1からN-1番目の島の景色を眺めていたいのだが、N番目の島に船を泊めてあるので、最終的にはN番目の島に到着していなければならない。また、船の中で両親を待たせているため、がっちょ君はN番目の島についたらすぐに船で出発して家へと帰らなければならない。

がっちょ君が橋を渡ったり島の中を移動する時間はとても短いので、0と仮定してよい。がっちょ君が1からN-1番目のいずれかの島にいることのできる時間の最大値を求めよ。ただし、どのように移動してもがっちょ君がN番目の島へと移動できない場合は代わりに-1を出力せよ。

Input

入力は以下の形式で与えられる。

N M
a1 b1 c1
a2 b2 c2
…
aM bM cM

1行目には、2つの整数N, Mが空白区切りで与えられる。

2行目からM+1行目のそれぞれの行iには、3つの整数ai, bi, ciが空白区切りで与えられる。

Constraints

2 ≤ N ≤ 105

1 ≤ M ≤ 2 × 105

1 ≤ ai < N

1 ≤ bi ≤ N

1 ≤ ci ≤ 109

ai ≠ bi

Output

がっちょ君がN番目の島へと移動できる場合は、がっちょ君が1からN-1番目のいずれかの島にいることのできる時間の最大値を出力する。N番目の島へと移動できない場合は、代わりに-1を出力する。

Sample Input 1

3 2
1 2 10
2 3 20

Sample Output 1

20

まず、1番目の島で時刻が10になるまで待ってから、2番目の島へと移動する。

次に、2番目の島で時刻が20になるまで待ってから、3番目の島へと移動する。

以上より、1から2番目のいずれかの島にいる時間は20となる。

Sample Input 2

4 4
1 2 27
1 3 37
2 3 47
3 1 57

Sample Output 2

-1

4番目の島に繋がる橋がないため、4番目の島へ移動することができない。

Sample Input 3

3 3
1 2 13
2 3 17
2 3 15

Sample Output 3

17

Sample Input 4

3 2
1 2 20
2 3 10

Sample Output 4

-1

Sample Input 5

3 2
1 2 10
2 3 10

Sample Output 5

10

Solution in JAVA (judge verdict: Wrong Answer)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {

	static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		int N = sc.nextInt();
		int M = sc.nextInt();
		ArrayList<ArrayList<Edge>> g = new ArrayList<>();
		for (int i = 0; i < N; ++i) {
			g.add(new ArrayList<>());
		}
		for (int i = 0; i < M; ++i) {
			int A = Integer.parseInt(sc.next()) - 1;
			int B = Integer.parseInt(sc.next()) - 1;
			int C = Integer.parseInt(sc.next());
			g.get(A).add(new Edge(B, C));
			g.get(B).add(new Edge(A, C));
		}
		PriorityQueue<State> q = new PriorityQueue<>();
		q.add(new State(0, 0));
		int[] time = new int[N];
		Arrays.fill(time, 2_000_000_000);
		boolean[] visited = new boolean[N];
		time[0] = 0;
		while (!q.isEmpty()) {
			State st = q.poll();
			if (visited[st.pos]) continue;
			visited[st.pos] = true;
			for (Edge e : g.get(st.pos)) {
				if (e.time < st.time) continue;
				if (time[e.next] <= st.time) continue;
				time[e.next] = st.time;
				q.add(new State(e.time, e.next));
			}
		}
		if (!visited[N - 1]) {
			System.out.println(-1);
			return;
		}
		int ans = 0;
		for (Edge e : g.get(N - 1)) {
			if (time[e.next] <= e.time) {
				ans = Math.max(ans, e.time);
			}
		}
		System.out.println(ans);
	}

	static class State implements Comparable<State> {
		int time, pos;

		public State(int time, int pos) {
			this.time = time;
			this.pos = pos;
		}

		public int compareTo(State o) {
			return Integer.compare(time, o.time);
		}
	}

	static class Edge {
		int next, time;

		public Edge(int next, int time) {
			this.next = next;
			this.time = time;
		}
	}

}