output_description: Print the number of ways to write positive integers in the vertices so that
  the condition is satisfied.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      n m
      u_1 v_1 s_1
      :
      u_m v_m s_m
attempt: import numpy as np
  
  
  def find(position):
      a = np.where(position == edge[0])[0]
      b = np.where(position == edge[1])[0]
      c = np.int32(np.append(a, b))
      d = np.int32(np.append(np.ones(len(a)), np.zeros(len(b))))
  
      return c, d
  
  
  def find_henkou_edge(henkousareta):
      inds = np.array([]).astype(np.int32)
      for a in henkousareta:
          ind, dotti = find(a)
          inds = np.append(inds, ind)
      inds = np.unique(inds)
  
      return inds
  
  
  def check(inds):
      ok = True
      for ind in inds:
          i = edge[:, ind]
          #         print(i)
          #         print(num[i])
          if (num[i] != -9999).all():
              #             print(num[i].any())
              if not sum(num[i]) == ss[ind]:
                  ok = False
      return ok
  
  
  def check_henkou(henkousareta):
      inds = find_henkou_edge(henkousareta)
      #     print(inds)
      ok = check(inds)
      return ok
  
  
  n, m = map(int, input().split())
  
  uu = []
  vv = []
  ss = []
  for k in range(m):
      u, v, s = map(int, input().split())
      uu.append(u)
      vv.append(v)
      ss.append(s)
  uu = np.array(uu) - 1
  vv = np.array(vv) - 1
  ss = np.array(ss)
  
  edge = np.vstack([uu, vv])
  
  mi = np.min(ss)
  armi = np.argmin(ss)
  num = np.int32(np.zeros(n)) - 9999
  cand = range(1, mi)
  
  ruikei = 0
  for c in cand:
      num = np.int32(np.zeros(n)) - 9999
      #     print(c)
      num[armi] = c
      ind_tar = armi
  
      while True:
          ind, dotti = find(ind_tar)
          henkousareta = []
          ok_for = True
          for k in range(len(ind)):
              temp = dotti[k], ind[k]
              temp = edge[temp]
              if num[temp] == -9999:
                  num[temp] = ss[ind[k]] - num[ind_tar]
                  if num[temp] < 1:
                      ok_for = False
                      break
              else:
                  if not num[temp] == ss[ind[k]] - num[ind_tar]:
                      ok_for = False
                      break
              henkousareta.append(temp)
          #         print(num)
          #         print(ok_for)
          if ok_for == False:
              ok = False
              break
          ok = check_henkou(henkousareta)
          #         print(henkousareta)
          if ok == False:
              break
          if not np.min(num) == -9999:
              break
          ind, dotti = find(np.where(num == -9999)[0][0])
          ind_tar = edge[dotti[0], ind[0]]
      #         print(num)
      ruikei += ok
  print(ruikei)
  
problem_description: Statement
  
  Kenkoooo found a simple connected graph. The vertices are numbered 1 through
  n. The i-th edge connects Vertex u_i and v_i, and has a fixed integer s_i.
  
  Kenkoooo is trying to write a _positive integer_ in each vertex so that the
  following condition is satisfied:
  
    * For every edge i, the sum of the positive integers written in Vertex u_i and v_i is equal to s_i.
  
  Find the number of such ways to write positive integers in the vertices.
samples: [{"input": "3 3\n    1 2 3\n    2 3 5\n    1 3 4", "output": "1\n    \n\nThe condition will be satisfied if we write 1,2 and 3 in vertices 1,2 and 3,\nrespectively. There is no other way to satisfy the condition, so the answer is\n1.\n\n* * *"}, {"input": "4 3\n    1 2 6\n    2 3 7\n    3 4 5", "output": "3\n    \n\nLet a,b,c and d be the numbers to write in vertices 1,2,3 and 4, respectively.\nThere are three quadruples (a,b,c,d) that satisfy the condition:\n\n  * (a,b,c,d)=(1,5,2,3)\n  * (a,b,c,d)=(2,4,3,2)\n  * (a,b,c,d)=(3,3,4,1)\n\n* * *"}, {"input": "8 7\n    1 2 1000000000\n    2 3 2\n    3 4 1000000000\n    4 5 2\n    5 6 1000000000\n    6 7 2\n    7 8 1000000000", "output": "0"}]