#include <bits/stdc++.h>

using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
const int NMAX =1000;
int capacitati[NMAX+5][NMAX+5];
///practic acesta matrice de capacitati reprezinta matricea de adiacenta a grafului residual
vector<int>g[NMAX+5];
int path[NMAX+5];
bool bfs(int start, int finish)
{
   queue<int>q;
   for(int i =1; i<=finish; i++)
      path[i] = -1;
   path[start] = 0;
   q.push(start);
   while(!q.empty())
   {
      int node = q.front();
      q.pop();
      for(int i =0; i < g[node].size(); i++)
      {
        int cnode = g[node][i];
        if(capacitati[node][cnode] > 0 && path[cnode] == -1)
        {
            q.push(cnode);
            path[cnode] = node;
        }
      }
    }
    return path[finish] != -1;
}
int edmond_karp(int start, int finish){

   int flowMax = 0;
   while(bfs(start, finish)){
      for(int i =0; i < g[finish].size(); i++)
      {
         ///pentru o mica optimizare amun vector in care retin nodurile care sunt penultimele dintr-un drum
         ///nodurile care sunt legate direct cu finish-ul
         int current = g[finish][i];
         if(path[current] == -1)
            continue;
         path[finish] = g[finish][i];
         int flow = INT_MAX;
         current = finish;
         while(path[current] != 0)
         {
            flow = min(flow, capacitati[path[current]][current]);
            current = path[current];
         }
         current = finish;
         while(path[current] != 0)
         {
             capacitati[path[current]][current] -= flow;
             capacitati[current][path[current]] += flow;
             current = path[current];
         }
         flowMax += flow;
      }
   }
   return flowMax;
}

int main()
{
    int n, m, i, a, b, c;
    fin>>n>>m;
    int start, finish;
    start = 1;
    finish = n;
    for(int i=0; i <m;i++)
    {
      fin>>a>>b>>c;
      capacitati[a][b] = c;
      g[a].push_back(b);
      g[b].push_back(a);
    }
    fout<<edmond_karp(start, finish);


    return 0;
}