#include <fstream>
#include <queue>
using namespace std;

ifstream cin ("maxflow.in");
ofstream cout ("maxflow.out");

struct Muchie { int nod_vecin , urmatorul , capacitate , flux; } muchii[10001];
int numar_noduri , numar_muchii , capat[1001] , sursa[10001];
queue <int> candidati;
bool vizitat[1001];

void Breadth_First_Search ()
{
    for (int indice = 1 ; indice <= numar_noduri ; indice++)
        { vizitat[indice] = false; }
        
    for (int indice = 1 ; indice <= numar_muchii ; indice++)
        { sursa[indice] = 0; }

    queue < pair <int , int> > optiuni;
    for (optiuni.push({1 , 0}) , vizitat[1] = true ; !optiuni.empty() ; optiuni.pop())
    {
        const int nod_actual = optiuni.front().first;
        for (int indice = capat[nod_actual] ; indice ; indice = muchii[indice].urmatorul) {
            if (!vizitat[muchii[indice].nod_vecin] && muchii[indice].capacitate > muchii[indice].flux) 
            {
                sursa[indice] = optiuni.front().second;
                if (muchii[indice].nod_vecin == numar_noduri)
                    { candidati.push(indice); continue; }

                optiuni.push({muchii[indice].nod_vecin , indice});
                vizitat[muchii[indice].nod_vecin] = true;
            }
        }
    }
}

int main ()
{
    cin >> numar_noduri >> numar_muchii;

    for (int indice = 1 , nod_actual ; indice <= numar_muchii ; indice++)
    {
        cin >> nod_actual >> muchii[indice].nod_vecin >> muchii[indice].capacitate;
        muchii[indice].urmatorul = capat[nod_actual];
        capat[nod_actual] = indice;
        muchii[indice].flux = 0;

        indice++; numar_muchii++;
        muchii[indice].nod_vecin = nod_actual;
        muchii[indice].urmatorul = capat[muchii[indice - 1].nod_vecin];
        muchii[indice].capacitate = muchii[indice - 1].capacitate;
        muchii[indice].flux = muchii[indice].capacitate;
        capat[muchii[indice - 1].nod_vecin] = indice;
    }

    int flux_total = 0;
    while (true) 
    {
        Breadth_First_Search();

        if (candidati.empty())
            { break; }
            
        for ( ; !candidati.empty() ; candidati.pop())
        {
            int flux_actual = INT32_MAX;
            const int indice = candidati.front();
            for (int _indice = indice ; _indice && flux_actual ; _indice = sursa[_indice])
                { flux_actual = min(flux_actual , muchii[_indice].capacitate - muchii[_indice].flux); }
            
            if (flux_actual) 
            {
                flux_total += flux_actual;
                for (int _indice = indice ; _indice && flux_actual ; _indice = sursa[_indice]) {
                    muchii[_indice + ((_indice & 1) ? 1 : -1)].flux -= flux_actual;
                    muchii[_indice].flux += flux_actual; 
                }    
            }
        }
    }

    cout << flux_total;
    cout.close(); cin.close();
    return 0;
}