#include<bits/stdc++.h>

using namespace std;

ifstream f("maxflow.in");
ofstream g("maxflow.out");

vector<int> parent;
vector<int> visited;
//vector<pair<int,int>> capacity[1001],flux[1001];
int capacity[1001][1001],flux[1001][1001];
vector<int> adjList[1001];
queue<int> q;
int maxflow=0;

int bfsFlux(int source,int destination){
    visited[source]++;
    q.push(source);
    int i;
    parent[source]=-1;

    while(!q.empty()){
        int first=q.front();
        q.pop();

        for(auto &w: adjList[first]){
            if(!visited[w] && capacity[first][w]-flux[first][w]){
                visited[w]=1;
                parent[w]=first;
                q.push(w);
            }
        }

    }

    return visited[destination];
}

int main(){
    int n,m;
    f>>n>>m;
    int a,b,c,i;

    for(i=0;i<m;++i){
        f>>a>>b>>c;
        adjList[a-1].push_back(b-1);
        capacity[a-1][b-1]=c;
        flux[a-1][b-1]=0;
        flux[b-1][a-1]=0;

    }

    for(i=0;i<n;++i)
    {
        visited.push_back(0);
        parent.push_back(-1);

    }

    while(bfsFlux(0,n-1)){
        int curr=n-1;
        int flux_min=1<<30;

        while(curr!=0){
            if(capacity[parent[curr]][curr]-flux[parent[curr]][curr]<flux_min){
                flux_min=capacity[parent[curr]][curr]-flux[parent[curr]][curr];
            }
            curr=parent[curr];
        }

        curr=n-1;

        while(curr!=0){
            flux[parent[curr]][curr]=flux[parent[curr]][curr]+flux_min;
            flux[curr][parent[curr]]=flux[curr][parent[curr]]-flux_min;


            curr=parent[curr];

        }

        int j;
        for(j=0;j<n;++j){
            visited[j]=0;
            parent[j]=-1;
        }

        maxflow=maxflow+flux_min;


    }

    g<<maxflow;
    return 0;
}