Problem:
Score : 400 points

Problem Statement

There are N people standing on the x-axis.
Let the coordinate of Person i be x_i.
For every i, x_i is an integer between 0 and 10^9 (inclusive).
It is possible that more than one person is standing at the same coordinate.

You will given M pieces of information regarding the positions of these people.
The i-th piece of information has the form (L_i, R_i, D_i).
This means that Person R_i is to the right of Person L_i by D_i units of distance, that is, x_{R_i} - x_{L_i} = D_i holds.

It turns out that some of these M pieces of information may be incorrect.
Determine if there exists a set of values (x_1, x_2, ..., x_N) that is consistent with the given pieces of information.

Constraints

1 \leq N \leq 100 000

0 \leq M \leq 200 000

1 \leq L_i, R_i \leq N (1 \leq i \leq M)

0 \leq D_i \leq 10 000 (1 \leq i \leq M)

L_i \neq R_i (1 \leq i \leq M)

If i \neq j, then (L_i, R_i) \neq (L_j, R_j) and (L_i, R_i) \neq (R_j, L_j).

D_i are integers.

Input

Input is given from Standard Input in the following format:

N M
L_1 R_1 D_1
L_2 R_2 D_2
:
L_M R_M D_M

Output

If there exists a set of values (x_1, x_2, ..., x_N) that is consistent with all given pieces of information, print Yes; if it does not exist, print No.

Sample Input 1

3 3
1 2 1
2 3 1
1 3 2

Sample Output 1

Yes

Some possible sets of values (x_1, x_2, x_3) are (0, 1, 2) and (101, 102, 103).

Sample Input 2

3 3
1 2 1
2 3 1
1 3 5

Sample Output 2

No

If the first two pieces of information are correct, x_3 - x_1 = 2 holds, which is contradictory to the last piece of information.

Sample Input 3

4 3
2 1 1
2 3 5
3 4 2

Sample Output 3

Yes

Sample Input 4

10 3
8 7 100
7 9 100
9 8 100

Sample Output 4

No

Sample Input 5

100 0

Sample Output 5

Yes

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)


import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Main m = new Main();
		m.run();
	}

	Scanner sc = new Scanner(System.in);

	void run() {

		int n = sc.nextInt();

		int m = sc.nextInt();
		int l[] = new int[m];
		int r[] = new int[m];
		int d[] = new int[m];

		Map<Integer, List<E>> map = new HashMap<Integer, List<E>>();

		for (int i = 0; i < m; i++) {
			l[i] = sc.nextInt();
			r[i] = sc.nextInt();
			d[i] = sc.nextInt();

			E e = new E(l[i], r[i], d[i]);
			List<E> leftList = map.containsKey(l[i]) ? map.get(l[i]) : new LinkedList<E>();
			// List<E> leftList = leftMap.getOrDefault(l[i], new
			// LinkedList<E>());
			leftList.add(e);
			map.put(l[i], leftList);

			List<E> rightList = map.containsKey(r[i]) ? map.get(r[i]) : new LinkedList<E>();
			rightList.add(e);
			map.put(r[i], rightList);
		}

		int[] line = new int[n + 1];
		boolean[] visited = new boolean[n + 1];
		int[] max = new int[n+1];
		int[] min = new int[n+1];
		
		{
			List<E> init = new LinkedList<E>();
			E e = new E(0, 1, 0);
			init.add(e);
			map.put(0, init);
			visited[0] = true;
		}

		for (int i = 1; i < n + 1; i++) {
			if (!map.containsKey(i)) {
				visited[i] = true;
				continue;
			}

			List<E> list = map.get(i);
			for (E e : list) {
				int targetId ;
				int targetPos ;
				if(e.l == i){
					targetId = e.r;
					targetPos = line[i]+e.d;
				}else{
					targetId = e.l;
					targetPos = line[i]-e.d;										
				}

				if(visited[targetId]){
					if(targetPos != line[targetId]){
						System.out.println("No");
						return;
					}
				}
				visited[targetId] = true;
				line[targetId] = targetPos;
				max[targetId] = Math.max(max[targetId], targetPos);
				min[targetId] = Math.min(min[targetId], targetPos);
				max[targetId] = Math.max(max[targetId], line[i]);
				min[targetId] = Math.min(min[targetId], line[i]);

				max[i] = Math.max(max[i], targetPos);
				min[i] = Math.min(min[i], targetPos);
				max[i] = Math.max(max[i], line[i]);
				min[i] = Math.min(min[i], line[i]);
				
				max[i] = Math.max(max[i], max[targetId]);
				max[targetId] = Math.max(max[i], max[targetId]);
				min[i] = Math.min(min[i], min[targetId]);
				min[targetId] = Math.min(min[i], min[targetId]);
			}
			visited[i] = true;
		}
		for(int i = 0 ; i < n + 1 ; i++){
			if(max[i] - min[i] > 1000000000){
				System.out.println("No");
				return;
			}
		}
		
		System.out.println("Yes");

	}

	class E {
		int l;
		int r;
		int d;

		E(int l, int r, int d) {
			this.l = l;
			this.r = r;
			this.d = d;
		}
	}

}