#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();

       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;
        ///initializam fluxul cu 0
        g[a][b] = 0;
        ///in graful rezidual semnalam ca putem sa trimitem c "obiecte"
        /// de la a la b
        gr[a][b] = c;
    }
    q.push(s);
    while(bfs())
    {

        ///vream sa computam i(P)  - capacitatea reziduala a drumului P in graful rezidual
        int nod = t;
        int capacity = inf;
        while(nod != s)
        {
            capacity = min(capacity,gr[tata[nod]][nod]);
            nod = tata[nod];

        }
        ///revizuim drumul si actualizam graful rezidual
        nod = t;
        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;
}