#include <bits/stdc++.h>

using namespace std;

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

const int NMAX = 1005;
const int MMAX = 5005;

vector <int> v[NMAX];
queue <int> q;
int capacitate[NMAX][NMAX],flux[NMAX][NMAX],tata[NMAX];
bool ver[NMAX];
int n,m,x,y,z,rasp;

void citire(){
    fin >> n >> m;
    for(int i=1;i<=m;i++){
        fin >> x >> y >> z;
        v[x].push_back(y);
        v[y].push_back(x);
        capacitate[x][y]=z;
    }
    return;
}

void print(){
    fout << rasp;
    return;
}

bool muchie_disponibila(int node1,int node2){
    if(capacitate[node1][node2]>flux[node1][node2])
        return true;
    return false;
}

int capacitate_ramasa(int node1,int node2){
    int cap_ramasa = capacitate[node1][node2]-flux[node1][node2];
    return cap_ramasa;
}

bool bfs(){
    /// incep cu nodul 1 , ma duc spre n
    /// ma duc pe o muchie doar daca capacitate > flux
    for(int i=1;i<=n;i++) ver[i]=false;
    q.push(1);
    ver[1]=true;
    while(!q.empty()){
        int node=q.front();
        q.pop();
        for(int i=0;i<v[node].size();i++){
            int vecin=v[node][i];
            if(ver[vecin]==false and muchie_disponibila(node,vecin)==true){
                ver[vecin]=true;
                tata[vecin]=node;
                q.push(vecin);
            }
        }
    }
    if(ver[n]==true) return true;
    return false;
}

void solve(){
    while(bfs()==true){
        for(int i=0;i<v[n].size();i++){
            int node = v[n][i];
            if(ver[node]==true and muchie_disponibila(node,n)==true){
                /// gasesc minimul pentru (capacitate-flux)
                /// a muchiilor din drumul de la 1 la n;
                int minim = capacitate[node][n]-flux[node][n];
                int aux = node;
                while(aux!=1){
                    if(capacitate_ramasa(tata[aux],aux) < minim)
                        minim = capacitate_ramasa(tata[aux],aux);
                    aux = tata[aux];
                }
                rasp+=minim;
                flux[node][n]+=minim;
                flux[n][node]-=minim;
                aux=node;
                while(aux!=1){
                    flux[tata[aux]][aux]+=minim;
                    flux[aux][tata[aux]]-=minim;
                    aux=tata[aux];
                }
            }
        }
    }
}

int main()
{
    citire();
    solve();
    print();
    return 0;
}