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 Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

;; -*- coding:utf-8 -*-

(defparameter *file-path* *load-pathname*)

(defun clip-to-string ()
  (with-output-to-string (out)
    (sb-ext:run-program "C:/msys64/usr/bin/cat.exe" '("/dev/clipboard") :output out)))

(defun test ()
  (with-input-from-string (*standard-input* (clip-to-string))
    (load *file-path*)))


(defstruct (queue (:constructor
		  $make-queue))
  arr
  (start 0 :type fixnum)
  (end 0 :type fixnum))

(defun make-queue (size)
  ($make-queue :arr (make-array size :initial-element nil)
	       :start 0
	       :end 0))

(defun null-queue (queue)
  "Gibt T zurück, wenn QUEUE leer ist."
  (= (queue-start queue) (queue-end queue)))

(defun enqueue (obj queue)
  (setf (aref (queue-arr queue) (queue-end queue)) obj)
  (incf (queue-end queue))
  queue)

(defun enqueue-list (lst queue)
  (if (null lst)
      queue
      (enqueue-list (cdr lst)
		    (enqueue queue (car lst)))))
	

(defun dequeue (queue)
  (if (null-queue queue)
      (error "QUEUE ist leer.")
      (prog1 (aref (queue-arr queue) (queue-start queue))
	(incf (queue-start queue)))))

(defun reset-queue (queue)
  (setf (queue-start queue) 0
	(queue-end queue) 0))

(defstruct edge
  (dest 0 :type fixnum)
  (weight 0 :type fixnum))

(defun read-graph (n m)
  (let ((graph (make-array n :element-type 'list :initial-element nil)))
    (dotimes (x m graph)
      (let* ((left (- (read) 1))
	     (right (- (read) 1))
	     (dist (read)))
	(push (make-edge :dest right :weight dist)
	      (aref graph left))
	(push (make-edge :dest left :weight (- dist))
	      (aref graph right))))))

(defun find-new-idx (graph table)
  (loop for idx from 0 below (length graph)
     do (when (and (aref graph idx)
		   (= (aref table idx) most-negative-fixnum))
	  (return idx))
     finally (return -1)))

(defun valid-p (graph)
  "Breitensuche."
  (let* ((size (length graph))
	 (queue (make-queue size))
	 (table (make-array size
			    :element-type 'fixnum
			    :initial-element most-negative-fixnum)))
    (loop named main-loop
       for new-idx = (find-new-idx graph table)
       until (= -1 new-idx)
       finally (return-from main-loop t)
       do
	 (reset-queue queue)
	 (enqueue new-idx queue)
	 (setf (aref table new-idx) 0) ; Die erste Zahl ist egal.
	 (loop named sub-loop
	    until (null-queue queue)
	    do (let* ((start-idx (dequeue queue))
		      (start-number (aref table start-idx))
		      (edges (aref graph start-idx)))
		 (dolist (edge edges)
		   (let ((dest-idx (edge-dest edge))
			 (dest-number (+ start-number (edge-weight edge))))
		     (cond ((= most-negative-fixnum (aref table dest-idx))
			    (setf (aref table dest-idx) dest-number)
			    (enqueue dest-idx queue))
			   ((/= (aref table dest-idx) dest-number)
			    (return-from main-loop nil))))))))))
	  
	

(defun main ()
  (let* ((n (read))
	 (m (read))
	 (graph (read-graph n m)))
    (format t (if (valid-p graph)
		  "Yes~%"
		  "No~%"))))
	

(main)