#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
/*
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
*/
using namespace std;

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

int N, M, S, D, a, b, c, ct;
int tata[1005];

vector <int> GRAF[1005];
int CAPACITATE[1005][1005];

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

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

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

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

                if(vec == destinatie)
                    return true;
                else
                {
                    viz[vec] = 1;
                    coada.push(vec);
                }
            }
        }
    }

    return false;
}


int main()
{
    fin>>N>>M;
    for (int i = 1; i <= M; ++i)
    {
        fin>>a>>b>>c;
        GRAF[a].push_back(b);
        GRAF[b].push_back(a);

        CAPACITATE[a][b] = c;

        if(c>cap_max)
            cap_max = c;

    }

    sursa = 1;
    destinatia = N;

    int flow_max = 0;
    while(bf(S,D))
    {
        int ip = cap_max;

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

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

        flow_max += ip;
    }

    cout<<flow_max;
    return 0;
}