#define INPUT
#ifdef INPUT
  #include <fstream>
#else
  #include <iostream>
#endif
#include <limits>
#include <algorithm>
#include <queue>

using namespace std;

#define MAX_M 5100
#define MAX_N 1100

typedef struct {
  uint32_t v, next;
} cell;

uint32_t N, M;
uint32_t adj[MAX_N + 1];
cell list[2 * MAX_M + 1];
uint32_t parent[MAX_N + 1];
int32_t capacity[MAX_N + 1][MAX_N + 1];
int32_t flow[MAX_N + 1][MAX_N + 1];
queue<uint32_t> q;

void addEdge(uint32_t index, uint32_t u, uint32_t v) {
  list[index].v = v;
  list[index].next = adj[u];
  adj[u] = index;
}

int32_t check(uint32_t u, uint32_t v) {
  return capacity[u][v] - flow[u][v];
}

bool bfs(uint32_t source, uint32_t sink) {
  for (uint32_t index = 1; index <= N; ++index)
    parent[index] = 0;
  parent[source] = 1;
  q.push(source);
  while (!q.empty()) {
    uint32_t u = q.front();
    q.pop();
    
    for (uint32_t pos = adj[u]; pos; pos = list[pos].next) {
      uint32_t v = list[pos].v;
      if ((!parent[v]) && (flow[u][v] != capacity[u][v])) {
        parent[v] = u;
        q.push(v);
      
        if (v == sink) {
          while (!q.empty()) q.pop();
          return true;
        }
      }
    }
  }  
  return false;
}

int32_t ford_fulkerson(uint32_t source, uint32_t sink) {
  int32_t maxFlow = 0;
  do {
    bool residualGraphHasPath = bfs(source, sink);
    if (!residualGraphHasPath)
      return maxFlow;
    int32_t minim = numeric_limits<int32_t>::max();
    for (uint32_t node = sink; node != source; node = parent[node])
      minim = min(minim, check(parent[node], node));
    maxFlow += minim;
    for (uint32_t node = sink; node != source; node = parent[node]) {
      flow[parent[node]][node] += minim;
      flow[node][parent[node]] -= minim;
    }
  } while (true);
  return maxFlow;
}

int main(void) {
#ifdef INPUT
  ifstream cin("maxflow.in");
  ofstream cout("maxflow.out");
#endif
  cin >> N >> M;
  for (uint32_t index = 1; index <= M; ++index) {
    uint32_t u, v, cap;
    cin >> u >> v >> cap;
    addEdge(index, u, v);
    addEdge(index + M, v, u);
    capacity[u][v] += cap;
  }
  cout << ford_fulkerson(1, N) << endl;
  return 0;
}