#include <fstream>
#include <vector>
#define DMAX 1004

using namespace std;

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

int n, m;
vector <int> g[DMAX];//graful neorientat
int c[DMAX][DMAX], f[DMAX][DMAX];//c=capacitatea, f=fluxul
int sursa, destinatie;
//BFS
int coada[DMAX];
bool uz[DMAX];
int anterior[DMAX];

void citire();
void initializare();
bool BFS();
void flux();

int main()
{
    citire();
    flux();
    return 0;
}

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

    sursa=1; destinatie=n;
}

void initializare()
{
    int i;
    for(i=1;i<=n;++i)
        uz[i]=0;
    uz[sursa]=1;
}

bool BFS()
{
    int x, v, i, lg;
    int prim=1, ultim=1;
    coada[1]=sursa;

    initializare();

    while(prim<=ultim)
    {
        x=coada[prim++];
        lg=g[x].size();
        for(i=0;i<lg;++i)
        {
            v=g[x][i];
            if(!uz[v] && f[x][v]<c[x][v])
            {
                uz[v]=1;
                anterior[v]=x;
                coada[++ultim]=v;

                if(v==destinatie)
                    return 1;
            }
        }
    }
    return 0;
}

void flux()
{
    int flux, minim, i;
    for(flux=0; BFS(); flux+=minim)
    {
        minim=999999999;
        for(i=destinatie;i!=sursa;i=anterior[i])
            minim=min(minim, c[anterior[i]][i]-f[anterior[i]][i]);
        for(i=destinatie;i!=sursa;i=anterior[i])
        {
            f[i][anterior[i]]-=minim;
            f[anterior[i]][i]+=minim;
        }
    }

    fout<<flux<<'\n';
}