#include <fstream>
#include <vector>
#include <queue>
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");
int graf[1001][1001];
int tati[1001];
bool vizitat[1001];
bool bfs(int n)
{
    queue<int> coada;

    for(int i = 1; i <= n; i++)
    {
        vizitat[i] = false;
        tati[i] = 0;
    }

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

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

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

    return false;
}
int flux(int n)
{
    int flux_maxim = 0;
    while(bfs(n))
    {
        for(int i = 1; i < n; i++)
        {
            if(graf[i][n] > 0 && vizitat[i] == true)
            {
                int penultim = i;

                vector<int> drum_c;
                drum_c.push_back(n);
                drum_c.push_back(penultim);

                int tata = tati[penultim];
                while(tata != 0)
                {
                    drum_c.push_back(tata);
                    tata = tati[tata];
                }

                int bottleneck = 110001;

                for(int i = 1; i < drum_c.size(); i++)
                {
                    bottleneck = min(bottleneck, graf[drum_c[i]][drum_c[i-1]]);
                }

                flux_maxim = flux_maxim + bottleneck;

                for(int i = 1; i < drum_c.size(); i++)
                {
                    graf[drum_c[i]][drum_c[i-1]] = graf[drum_c[i]][drum_c[i-1]] - bottleneck;
                    graf[drum_c[i-1]][drum_c[i]] = graf[drum_c[i-1]][drum_c[i]] + bottleneck;
                }
            }
        }
    }

    return flux_maxim;
}
int main()
{
    int n, m;

    f >> n >> m;

    int a, b, c;

    for(int i = 0; i < m; i++)
    {
        f >> a >> b >> c;
        graf[a][b] = c;
    }

    g << flux(n);
    return 0;
}