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

ifstream f("maxflow.in");
ofstream g("maxflow.out");

vector<int>tata,viz;
vector<vector<int> > cap,cap_drum;//capacitatea
int n,m,t,s;

bool BFS()
{
    vector<int> viz(n+1);
    queue<int> coada;
    coada.push(s);

    tata[s] = -1;
    viz[s] = 1;

    while(!coada.empty())
    {
        int u = coada.front();
        coada.pop();
        for(auto v:cap_drum[u])
        {
            if(cap[u][v]!=0 && viz[v]==0)
            {
                tata[v] = u;
                if(v == t)
                    return true;
                viz[v] = 1;
                coada.push(v);
            }
        }
    }
    return false;
}

int EdmondsKarp()
{
    long cap_max=0;
    while(BFS()==true) //cat timp exista un lant nevizitat
    {
        int u,v=t;
        int cap_lant=999999;
        //parcurgem de 2 ori lantul de la nodul final la cel de start
        //prima data pentru a cauta capacitatea minima
        //iar a 2a oara pentru a actualiza capacitatile muchiilor din lant pentru eventuale fluxuri viitoare
        while(v!=s)
        {
            u=tata[v];
            if(cap[u][v]<cap_lant)
                cap_lant=cap[u][v];
            v=tata[v];
        }
        v=t;
        while(v!=s)
        {
            u=tata[v];
            cap[v][u]+=cap_lant; // capacitatea muchiei inverse creste
            cap[u][v]-=cap_lant; // capacitatea muchiei din graful initial scade
            v=tata[v];
        }
        cap_max+=cap_lant;
    }
    return cap_max;
}
int main()
{
    int u,v,z;
    f>>n>>m;
    s=1; t=n;
    tata.resize(n+1);
    cap.resize(n+1, vector<int>(n+1));
    cap_drum.resize(n+1);
    for(int i=1; i<=m; i++)
    {
        // muchie de la u la v cu capacitatea z
        f>>u>>v>>z;
        cap_drum[u].push_back(v);
        cap_drum[v].push_back(u);
        cap[u][v]=z;
    }
    g << EdmondsKarp();
    return 0;
}