#include <fstream>
#include <iostream>
#include <vector>
#include <queue>
#include <limits>

#define SuperStart 0
#define SuperSink (N-1)

using namespace std;
vector<vector<int>> Flow, Capacity, Graph;
vector<int> daddy;

void addEdge(int from, int to, int capacity)
{
  Graph[from].emplace_back(to);
  Capacity[from][to] += capacity;
}

bool BFS(int k, int N)
{
  queue<int> Q;
  vector<bool> used;
  used.resize(N);
  used[k] = true;
  Q.push(k);

  while (!Q.empty()) {
    k = Q.front();
    Q.pop();
    if (k == SuperSink)
      continue;
    for (auto v: Graph[k])
      if(!used[v] && Capacity[k][v] > Flow[k][v]) {
	daddy[v] = k;
	used[v] = true;
	Q.push(v);
      }
  }
  return used[SuperSink];
}

int main()
{
  ifstream fin("maxflow.in");
  ofstream fout("maxflow.out");

  fin.sync_with_stdio(false);
  fin.tie(0);
  fout.sync_with_stdio(false);
  fout.tie(0);

  int N, M;
  fin >> N >> M;

  Graph.resize(N);
  Flow.resize(N);
  Capacity.resize(N);
  daddy.resize(N);
  fill(Flow.begin(), Flow.end(), vector<int>(N));
  fill(Capacity.begin(), Capacity.end(), vector<int>(N));
  
  for (int i = 0; i < M; ++i) {
    int a, b, c;
    fin >> a >> b >> c;
    --a; --b;
    addEdge(a, b, c);
    addEdge(b, a, -c);    
  }

  int maxFlow = 0;

  while (BFS(SuperStart, N))
    for (auto v: Graph[SuperSink]) {
      daddy[SuperSink] = v;

      int bottleNeck = numeric_limits<int>::max();
      for (int k = SuperSink; bottleNeck > 0 && k != SuperStart; k = daddy[k])
	bottleNeck = min(bottleNeck, Capacity[daddy[k]][k] - Flow[daddy[k]][k]);

      if (bottleNeck == 0) continue;
      maxFlow += bottleNeck;

      for (int k = SuperSink; k != SuperStart; k = daddy[k]) {
	Flow[daddy[k]][k] += bottleNeck;
	Flow[k][daddy[k]] -= bottleNeck;
      }
    }

  fout << maxFlow << "\n";
  
  return 0;
}