#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;
/*
Algoritm generic de determinare a unui flux maxim
ALGORITMUL FORD FULKERSON
initializeaza flux nul
Cat timp exista un s-t lant f-nesaturat P in G
            determina un astfel de lant P..
            revizuieste fluxul f de-a lungul lantului P
returneaza f

edmonds karp cu graf rezidual
initializeaza_flux_nul()
construim gf graful rezidual pentru f
cat timp exista un s-t drum in gf (drum de crestere)
    determina p un s-t drum minim in gf folosind bf pentru arcele cu cf(e)>0
    actualizeaza gf ( pentru e din e(p) inclusa in e(gf). arc -cfP arc invers + cfP
returneaza f
*/

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

int N, M, a, b, c, cap_max, sursa, destinatia;

vector <vector<int>> GRAF;
vector <vector<int>> CAPACITATE;
vector<int> tata;

bool bf(int sursa, int destinatia)
{
    vector<bool> viz(N+1,false);
    queue<int> coada;

    coada.push(sursa);
    tata[sursa] = -1;
    viz[sursa] = 1;

    while(!coada.empty())
    {
        int nod = coada.front();
        coada.pop();

        for(int vec : GRAF[nod])
        {
            if(viz[vec] == false && CAPACITATE[nod][vec])
            {
                tata[vec] = nod;

                if(vec == destinatia)
                    return true;
                viz[vec] = true;
                coada.push(vec);

            }
        }
    }
    return false;
}


int main()
{
    fin>>N>>M;

    sursa = 1;
    destinatia = N;

    tata.resize(N+1);
    GRAF.resize(N+1);
    CAPACITATE.resize(N + 1, vector<int>(N + 1));

    for (int i = 0; i < M; i++ )
    {
        fin>>a>>b>>c;

        if(c>=cap_max)
            cap_max = c;

        GRAF[a].push_back(b);
        GRAF[b].push_back(a);

        CAPACITATE[a][b] = c;

    }

    int flow_max = 0;
    while( bf(sursa,destinatia) )
    {
        int ip = INT_MAX;

        ///calculam capacitatea reziduala a lantului
        for (int i= destinatia; i != sursa; i = tata[i])
            ip = min(ip, CAPACITATE[tata[i]][i]);

        for (int i= destinatia; i != sursa; i = tata[i])
        {
            CAPACITATE[tata[i]][i] -= ip;
            CAPACITATE[i][tata[i]] += ip;
        }

        flow_max += ip;
    }

    fout<<flow_max;
    return 0;
}