#include <iostream>
#include <queue>
#include <fstream>
#include <algorithm>
#include <cmath>

using namespace std;
//infoarena - varinta 2, neoptimizata
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

int inf = 100000;
vector<int> tata (1002,0),viz(1002,0);

int n, m, s, t;
int f[1002][1002];
vector <int> ad[1002];
int c[1002][1002];
queue<int> q;
///o sa fac un bfs care sa imi intoarca true daca a fost
///gasit un path de la s la t si false altfel
bool bfs()
{
    bool found = false;
    while(!q.empty())
    {
        int nod = q.front();
        for(auto &i: ad[nod])
        {
            ///daca nodul nu a fost deja vizitat si putem sa
            ///schimbam
            ///daca avem arc direct
            if((c[nod][i] && c[nod][i] - f[nod][i] > 0) && viz[i] == 0)
            {
                q.push(i);
                if( i == t)
                    found = true;
                viz[i] = 1;
                tata[i] = nod;
            }
            ///daca avem arc invers
            else if( (c[i][nod] && f[i][nod] > 0) && viz[i] == 0)
            {
                q.push(i);
                if( i == t)
                    found = true;
                viz[i] = 1;
                ///pentru arcele inverse retinem tatii cu -
                tata[i] = - nod;
            }
        }

        q.pop();
    }
    return found;

}
int main()
{
    int flux = 0;
    fin >> n >>m;
    s = 1;
    t = n;
    for(int i  = 1; i <=m ; i++)
    {
        int a,b,cap;
        fin>>a>>b>>cap;

        c[a][b] = cap;
        f[a][b] = 0;

        ad[a].push_back(b);
        ad[b].push_back(a);
    }
    ///b.
    q.push(s);
    viz[s] = 1;
    while(bfs())
    {
        int nod = t;
        int capacity = inf;
        while(nod != s)
        {
            if(tata[nod] < 0)
                capacity = min(capacity, f[nod][abs(tata[nod])]);
            else
                capacity = min(capacity,c[abs(tata[nod])][nod] - f[abs(tata[nod])][nod]);

            nod = abs(tata[nod]);

        }

        ///revizuim drumul s
        nod = t;
        while(nod != s)
        {

            ///daca avem arc invers
            if(tata[nod] < 0)
                f[nod][abs(tata[nod])] -= capacity;
            else
                f[abs(tata[nod])][nod] += capacity;

            nod = abs(tata[nod]);
        }
        q.push(s);
        fill(tata.begin(),tata.end(),0);
        fill(viz.begin(),viz.end(),0);
        viz[s] = 1;
    }
    ///valoarea  fluxului maxim este egal cu nr de "obiecte" care ies din sursa
    for(auto &nod: ad[s])
    {
        flux += f[s][nod];
    }
    fout<<flux;

    return 0;
}