#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

int n, m, s, t;
// o matrice pentru capacitati si o matrice pentru fluxurile maxime

vector<vector<int>> capacitati;
vector<vector<int>> flux;
vector<pair<int, pair<int, int>>> lista;

vector<int> viz;
vector<int> tata;

void inintializare()
{
    capacitati.resize(n+1);
    flux.resize(n+1);
    for(int i = 1; i <= n; i++)
    {
        capacitati[i].resize(n+1, 0);
        flux[i].resize(n+1, 0);
    }

    for(int i = 0; i < m; i++)
    {
        int x, y, f_max;
        x = lista[i].first;
        y = lista[i].second.first;
        f_max = lista[i].second.second;
        capacitati[x][y] = f_max; 
    }
}

void constructie_lant_st_nesat_BF(int &ok)
{
    tata.assign(n+1, 0);
    viz.assign(n+1, 0);
    queue<int> coada;
    coada.push(s);
    viz[s] = 1;
    while(!coada.empty())
    {
        int i = coada.front();
        coada.pop();
        for(auto linie : lista)
        {
            int x, y, f_max;
            x = linie.first;
            y = linie.second.first;
            //f_max = lista[i].second.second;
            if(x == i)
            {
                if(viz[y] == 0 && capacitati[i][y] - flux[i][y] > 0)
                {
                    coada.push(y);
                    viz[y] = 1;
                    tata[y] = i;
                    if(y == t)
                    // stop si returnez 1;
                    {
                        ok = 1;
                        return;
                    }
                }
            }
            if(y == i)
            {
                if(viz[x] == 0 && flux[x][i] > 0)
                {
                    coada.push(x);
                    viz[x] = 1;
                    tata[x] = -i;
                    if(x == t)
                    {
                        ok = 1;
                        return;
                    }
                }
            }
        }
    }
    ok = 0;
    return;
}

//capaciatea unui lant de crestere este minimul capacitatilor reziduale ale arcelor componente
//unde pentru un arc direct capacitatea reziduala este c - f, iar pentru un arc invers este f
int calculeazaFlux()
{
    int iP = 1e9; //
    int v = t;

    while(v != s)
    {
        int u = abs(tata[v]);
        if(tata[v] > 0) // vrific daca muchia este arc direct
        {
            iP = min(iP, capacitati[u][v] - flux[u][v]);
        }
        else
        {
            iP = min(iP, flux[v][u]);
        }
        v = u;
    }
    return iP;
}

void actualizeazaFlux(int iP)
{
    int v = t;

    while(v != s)
    {
        int u = abs(tata[v]);
        if(tata[v] > 0)
        {
            flux[u][v] += iP;
        }
        else
        {
            flux[v][u] -= iP;
        }
        v = u;
    }
}

int main()
{
    int x, y, f, flux_maxim = 0;
    cin >> n >> m;
    s = 1;
    t = n;
    for(int i = 0; i < m; i++)
    {
        cin >> x >> y >> f;
        lista.push_back({x, {y, f}});
    }

    int ok = 1;
    inintializare();
    while(ok == 1)
    {
        constructie_lant_st_nesat_BF(ok);
        if(ok == 0) break;

        int iP = calculeazaFlux();
        actualizeazaFlux(iP);
        flux_maxim += iP;
 
    }
    cout << flux_maxim;
    return 0;
}