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

using namespace std;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
///o sa implementez a doua varianta prezentata la curs - gasesc fluxul
/// maxim folosindu-ma de graful rezidual si retin arborele bfs cu ajutorul
///unui array de tati
/// de asemenea, o sa retinem  graful folosindu-ne de o matrice de adiacenta
/// pentru care g[i][j] = capacitatea arcului cu extremitatiile (i,j) daca (i,j) apartine lui E
//                        0, altfel

int inf = 100000;
vector<int> tata (1002,0),viz(1002,0);
int n, m, s, t;
int g[1002][1002], gr[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();
        if(nod != t)
            for(int i = 1; i <=n  ; i++)
            {
                if(gr[nod][i] && viz[i] == 0)
                {
                    q.push(i);

                    if( i == t)
                        found = true;
                    viz[i] = 1;
                    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,c;
        fin>>a>>b>>c;
        g[a][b] = c;
        ///in graful rezidual semnalam ca putem sa trimitem c "obiecte"
        /// de la a la b
        gr[a][b] = c;
    }
    q.push(s);
    while(bfs())
    {

        ///pentru toate varfurile x, adiacente  cu varful destinatie t, care stiu ca apartin arborelui bfs, si pentru care stiu
        ///ca : 1. exista un arc (x,t) in graful rezidual (adica pot sa transport obiecte de la x la t de o anumita capacitate)
        ///     2. f(xt) != capacitate (xt) (inca mai am loc sa transport obiecte)

        for(int i = 1; i < n; i++)
        {


            if(gr[i][n] && viz[i] == 1 && gr[n][i] != g[i][n] && g[i][n])
            {


                ///vream sa computam i(P)  - capacitatea reziduala a drumului P in graful rezidual

                int nod = i;
                int capacity = gr[i][n];
                while(nod != s)
                {
                    capacity = min(capacity,gr[tata[nod]][nod]);
                    nod = tata[nod];

                }

                ///revizuim drumul si actualizam graful rezidual
                nod = i;
                gr[nod][n] -= capacity;
                gr[n][nod] += capacity;
                while(nod != s)
                {

                    gr[tata[nod]][nod] -= capacity;
                    gr[nod][tata[nod]] += capacity;
                    nod = tata[nod];
                }
                flux += capacity;
            }
        }
        q.push(s);
        fill(tata.begin(),tata.end(),0);
        fill(viz.begin(),viz.end(),0);
    }
    fout<< flux;
    return 0;
}