//Algoritmul Edmonds-Karp
//Optimizare a algoritmului lui Ford-Fulkerson

#include<fstream>
#include<iostream>
#include<vector>
#include <cstring>
#define INF 0x3f3f3f3f
using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");



int n,m,k,i,j,p,x,y,t,cap,flux,fmin;
int C[1024][1024],F[1024][1024],coada[1024],viz[1024],precedent[1024];
///F[i][j] = fluxul curent dintre nodul i si j
///C[i][j] = capacitatea dintre nodul i si j


vector <int> v[1024];
vector <int> frunze;

bool bfs()
{
    int nod, i, vecin,dr,st;
    st=dr=1;
    coada[st] = 1;
    viz[1] = 1;
    for(i=2;i<=n;i++)
    {
        viz[i] = 0;
    }

    while(st <= dr)
    {
        nod = coada[st];
        for(i=0;i<v[nod].size();i++)
        {
            vecin = v[nod][i];
            if(viz[vecin] == 0 and C[nod][vecin] != F[nod][vecin]) //daca muchia nu este saturata
            {
                dr++;
                coada[dr] = vecin;
                viz[vecin] = 1;
                precedent[vecin] = nod;
                if(vecin == n)
                    return true;
            }
        }
        st++;
    }
    return false;

}

int main()
{
    fin >> n >> m;
    for(i=1;i<=m;i++)
    {
        fin >> x >> y >> cap;
        C[x][y] += cap;
        v[x].push_back(y);
        v[y].push_back(x);
        if(y == n)
        {
            frunze.push_back(x);
        }

    }
    flux = 0;
    ///cand nu mai gasim drum de la sursa la destinatie inseamna ca fluxul este maxim
    while(bfs() == true)
    {
        for(j = 0; j < frunze.size(); j++)
        {
            int nod = frunze[j];
            if(viz[nod] == 1 && C[nod][n] != F[nod][n])
            {
                precedent[n] = nod;
                fmin = INF;
                nod = n;
                while(nod != 1)
                {
                    fmin = min(fmin, C[precedent[nod]][nod] - F[precedent[nod]][nod]);
                    nod = precedent[nod];
                }
                nod = n;
                while(nod != 1)
                    {
                        F[precedent[nod]][nod] += fmin;
                        F[nod][precedent[nod]] -= fmin;
                        nod = precedent[nod];
                    }
                flux = flux + fmin;

            }

        }
    }
    fout << flux << "\n";
}