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

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

int n, m, x, y, capacitate;
vector<vector<int>> graf(1001, vector<int>(1001));
queue <int> coada;
vector<bool> vizitat(1001, false);
vector<int> parinte(1001);

bool bfs()
{
    coada = queue <int> (); // golesc coada
    fill(vizitat.begin(), vizitat.end(), false);
    fill(parinte.begin(), parinte.end(), -1);

    coada.push(1);
    vizitat[1] = true;

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

        for(int i = 0; i <= n; i++)
        {
            if(graf[nod][i] > 0 && !vizitat[i])
            {
                coada.push(i);
                vizitat[i] = true;
                parinte[i] = nod;
                if(i == n)
                {
                    return true;
                }
            }
        }
    }
    return false;
}
int FluxMaxim()
{
    int fluxMaxim = 0;

    while(bfs())
    {
        for(int u = 1; u < n; u++)
        {
            if(graf[u][n] > 0 && vizitat[u])
            {
                vector<int> drum;
                int capacitateMinima = INT_MAX;
                drum.push_back(n);
                drum.push_back(u);

                int tata = parinte[u];

                while(tata != -1)
                {
                    drum.push_back(tata);
                    tata = parinte[tata];
                }

                for(long unsigned int v = 1; v < drum.size(); v++)
                    capacitateMinima = min(capacitateMinima, graf[drum[v]][drum[v - 1]]);

                fluxMaxim = fluxMaxim + capacitateMinima;

                for(long unsigned int v = 1; v < drum.size(); v++) {
                    graf[drum[v]][drum[v - 1]] -= capacitateMinima;
                    graf[drum[v - 1]][drum[v]] += capacitateMinima;
                }
            }
        }
    }

    return fluxMaxim;
}
int main()
{
    f >> n >> m;

    for(int i = 0; i < m; i++) {
        f >> x >> y >> capacitate;
        graf[x][y] = capacitate;
    }

    g << FluxMaxim();
    return 0;
}