output_description: 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`.
  
  * * *
input_description: 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
attempt: import heapq
  
  
  def dijkstra(nodes, N):
      dist = [float("inf") for i in range(N + 2)]
      prev = [float("inf") for i in range(N + 2)]
  
      dist[0] = 0
      q = []
      heapq.heappush(q, (0, 0))
  
      while len(q) != 0:
          prov_cost, src = heapq.heappop(q)
          if dist[src] < prov_cost:
              continue
  
          for nextnum, dis in nodes[src].nextnode:
              cost = dis
              if dist[nextnum] >= dist[src] + cost:
                  dist[nextnum] = dist[src] + cost
                  heapq.heappush(q, (dist[nextnum], nextnum))
                  prev[nextnum] = src
  
      return get_path(N + 1, prev)
  
  
  def get_path(goal, prev):
      path = [goal]
      dest = goal
  
      while prev[dest] != float("inf"):
          path.append(prev[dest])
          dest = prev[dest]
  
      return list(reversed(path))
  
  
  class People:
      def __init__(self, num):
          self.nodenum = num
          self.nextnode = []
  
      def set_node(self, num, dis):
          self.nextnode.append((num, dis))
  
      def node_adj(self):
          if self.nextnode == []:
              self.nextnode.append((self.nodenum + 1, 0))
  
  
  N, M = (int(i) for i in input().split())
  
  nodes = []
  for i in range(N + 2):
      nodes.append(People(i))
  
  for i in range(M):
      L, R, D = (int(i) for i in input().split())
      nodes[L].set_node(R, D)
  
  for i in range(N + 1):
      nodes[i].node_adj()
  
  ans = dijkstra(nodes, N)
  
  flag = True
  for i in range(N + 1):
      if ans[i] != i:
          flag = False
  if flag:
      print("Yes")
  else:
      print("No")
  
problem_description: 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.
samples: [{"input": "3 3\n    1 2 1\n    2 3 1\n    1 3 2", "output": "Yes\n    \n\nSome possible sets of values (x_1, x_2, x_3) are (0, 1, 2) and (101, 102,\n103).\n\n* * *"}, {"input": "3 3\n    1 2 1\n    2 3 1\n    1 3 5", "output": "No\n    \n\nIf the first two pieces of information are correct, x_3 - x_1 = 2 holds, which\nis contradictory to the last piece of information.\n\n* * *"}, {"input": "4 3\n    2 1 1\n    2 3 5\n    3 4 2", "output": "Yes\n    \n\n* * *"}, {"input": "10 3\n    8 7 100\n    7 9 100\n    9 8 100", "output": "No\n    \n\n* * *"}, {"input": "100 0", "output": "Yes"}]