// Bellman-Ford - O(n*m)
#include <iostream>
#include <fstream>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <cctype>
#include <unordered_map>
#include <cmath>
#include <bitset>
#include <set>
#include <string>
#include <cstring>
#include <algorithm>
#include <deque>
using namespace std;
ifstream in("maxflow.in");
ofstream out("maxflow.out");
typedef pair <int,int>iPair;
int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,S,t,x,y,z,ok,nr,C,xc,yc,ans,Min,w,v,weight,u,poz,cost,Max,MOD,val,lvl,MAX,current,st,dr,BASE,mid,semn,T,check,nr0,nrimp,nrpar,block,INF;
int capacity[1005][1005];
int flowpassed[1005][1005];
int cpc[1005];
vector<int>graf[1005];

int bfs(int s, int t, vector<int>& parent) {
  for(i=0;i<=n;i++){
    cpc[i]=0;
    parent[i]=-1;
  }
    parent[s] = -2;
    cpc[s]=INF;
    queue<int> q;
    q.push(s);
    while (!q.empty()) {
        int curr = q.front();
        q.pop();
        for (int next : graf[curr]) {
            if (parent[next] == -1 && capacity[curr][next]-flowpassed[curr][next]>0) {
                parent[next] = curr;
                cpc[next] = min(cpc[curr], capacity[curr][next]-flowpassed[curr][next]);
                if (next == t)
                    return cpc[t];
                q.push(next);
            }
        }
    }

    return 0;
}

int maxflow(int s, int t) {
    int flow = 0;
    vector<int> parent(n+5);
    int new_flow;
    while (new_flow = bfs(s, t, parent)) {
        flow += new_flow;
        int curr = t;
        while (curr != s) {
            int prev = parent[curr];
            flowpassed[prev][curr] += new_flow;
            flowpassed[curr][prev] -= new_flow;
            curr = prev;
        }
    }

    return flow;
}
int main()
{
  in>>n>>m;
  INF=999999999;
  for(i=1;i<=m;i++){
    in>>x>>y>>z;
    graf[x].push_back(y);
    graf[y].push_back(x);
    capacity[x][y]=z;
    capacity[y][x]=0;
  }
  s=1;
  t=n;
  out<<maxflow(s,t);
   return 0;
}