output_description: Print the maximum flow.
input_description: A flow network is given in the following format.
  
  $|V|\;|E|$  
  $u_0\;v_0\;c_0$  
  $u_1\;v_1\;c_1$  
  :  
  $u_{|E|-1}\;v_{|E|-1}\;c_{|E|-1}$  
    
  
  $|V|$, $|E|$ is the number of vertices and edges of the flow network
  respectively. The vertices in $G$ are named with the numbers 0, 1,...,
  $|V|-1$. The source is 0 and the sink is $|V|-1$.
  
  $u_i$, $v_i$, $c_i$ represent $i$-th edge of the flow network. A pair of $u_i$
  and $v_i$ denotes that there is an edge from $u_i$ to $v_i$ and $c_i$ is the
  capacity of $i$-th edge.
attempt: import collections
  
  
  def bfs(u, n):
      global level, network
      level = [-1] * n
      deq = collections.deque()
      level[u] = 0
      deq.append(u)
      while deq:
          v = deq.popleft()
          for w, c, l in network[v]:
              if c > 0 and level[w] < 0:
                  level[w] = level[v] + 1
                  deq.append(w)
  
  
  def dfs(u, t, f):
      global it, level, network
      if u == t:
          return f
      for i in range(it[u], len(network[u])):
          v, c, l = network[u][i]
          if c <= 0 or level[u] >= level[v]:
              continue
          d = dfs(v, t, min(f, c))
          if d <= 0:
              continue
          network[u][i][1] -= d
          network[v][l][1] += d
          it[u] = i
          return d
      it[u] = len(network[u])
      return 0
  
  
  def max_flow(s, t, n):
      global it, level
      flow = 0
      while True:
          bfs(s, n)
          if level[t] < 0:
              return flow
          it = [0] * n
          while True:
              f = dfs(s, t, 1e10)
              if f > 0:
                  flow += f
              else:
                  break
      return flow
  
  
  n, m = map(int, input().split())
  
  network = [[] for _ in range(n)]
  for _ in range(m):
      u, v, c = map(int, input().split())
      network[u].append([v, c, len(network[v])])
      network[v].append([u, 0, len(network[u]) - 1])
  
  level = [-1] * n
  it = [0] * n
  
  print(max_flow(0, n - 1, n))
  
problem_description: Maximum Flow
  
  A flow network is a directed graph which has a $source$ and a $sink$. In a
  flow network, each edge $(u, v)$ has a capacity $c(u, v)$. Each edge receives
  a flow, but the amount of flow on the edge can not exceed the corresponding
  capacity. Find the maximum flow from the $source$ to the $sink$.
samples: [{"input": "4 5\n    0 1 2\n    0 2 1\n    1 2 1\n    1 3 1\n    2 3 2", "output": "3"}]