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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using System.Collections;

namespace Equeue
{
    
    
    class Equeue
    {
      static Node[] Nodes;
        static void Main(string[] args)
        {
            var NM = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var N = NM[0];
            var M = NM[1];
          
            Nodes = new Node[N+1];
            
            for(int i = 1;i <= N ;i++){
              Nodes[i] = new Node();
            }
            
            var cand = new long[N+1];
            for(int i = 0;i < M ;i++){
              var LRD = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
              var L = LRD[0];
              var R = LRD[1];
              var D = LRD[2];
              
              cand[L] = 1;
              cand[R] = 1;
              Nodes[L].adj.Add(R,-D);
              Nodes[R].adj.Add(L,D);
            }
            
            var ans = true;
            for(int i = 1;i <= N ;i++){
              if(cand[i] == 1 && Nodes[i].loc == -1){
                ans = WFS(i);
              }
              if(!ans){
                break;
              }
            }
            

            Console.WriteLine(ans ? "Yes":"No");
        }
      
      
        static bool WFS(long st){
          var q = new Queue<Node>();
          var tmp = Nodes[st];
          tmp.loc = 100;
          q.Enqueue(tmp);
          long max = tmp.loc;
          long min = tmp.loc;
          
          while(q.Count > 0){
            tmp = q.Dequeue();
            foreach(KeyValuePair<long,long> item in tmp.adj) {
              var child = Nodes[item.Key];
              //Console.WriteLine(item.Key+" "+child.loc+" "+item.Value);
              if(child.loc != -1 && (child.loc != (item.Value+tmp.loc))){
                return false;
              }else if(child.loc == long.MinValue){
                child.loc = item.Value+tmp.loc;
               max = Math.Max(max,child.loc);
               min = Math.Min(min,child.loc); q.Enqueue(Nodes[item.Key]);
                //Console.WriteLine(item.Key+" "+child.loc+" "+item.Value);
              }
              
            }
          }
          if(max-min <= 1000000000){
              return true;
          }else{
              return false;
          }
          
        }      
      
    }
  


    public class Node{
      public long loc = long.MinValue;
      public Dictionary<long,long> adj = new Dictionary<long,long>();
    }
  
  
    public class PriorityQueue<T> : IEnumerable<T>
    {
        private readonly List<T> _data = new List<T>();
        private readonly IComparer<T> _comparer;
        private readonly bool _isDescending;

        public PriorityQueue(IComparer<T> comparer, bool isDescending = true)
        {
            _comparer = comparer;
            _isDescending = isDescending;
        }

        public PriorityQueue(Comparison<T> comparison, bool isDescending = true)
            : this(Comparer<T>.Create(comparison), isDescending)
        {
        }

        public PriorityQueue(bool isDescending = true)
            : this(Comparer<T>.Default, isDescending)
        {
        }

        public void Enqueue(T item)
        {
            _data.Add(item);
            var childIndex = _data.Count - 1;
            while (childIndex > 0)
            {
                var parentIndex = (childIndex - 1) / 2;
                if (Compare(_data[childIndex], _data[parentIndex]) >= 0)
                    break;
                Swap(childIndex, parentIndex);
                childIndex = parentIndex;
            }
        }

        public T Dequeue()
        {
            var lastIndex = _data.Count - 1;
            var firstItem = _data[0];
            _data[0] = _data[lastIndex];
            _data.RemoveAt(lastIndex--);
            var parentIndex = 0;
            while (true)
            {
                var childIndex = parentIndex * 2 + 1;
                if (childIndex > lastIndex)
                    break;
                var rightChild = childIndex + 1;
                if (rightChild <= lastIndex && Compare(_data[rightChild], _data[childIndex]) < 0)
                    childIndex = rightChild;
                if (Compare(_data[parentIndex], _data[childIndex]) <= 0)
                    break;
                Swap(parentIndex, childIndex);
                parentIndex = childIndex;
            }
            return firstItem;
        }

        public T Peek()
        {
            return _data[0];
        }

        private void Swap(int a, int b)
        {
            var tmp = _data[a];
            _data[a] = _data[b];
            _data[b] = tmp;
        }

        private int Compare(T a, T b)
        {
            return _isDescending ? _comparer.Compare(b, a) : _comparer.Compare(a, b);
        }

        public int Count => _data.Count;

        public IEnumerator<T> GetEnumerator()
        {
            return _data.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }
}