#include <bits/stdc++.h>

using namespace std;

const int Nmax = 1000 + 1;
const int Mmax = 5000 + 1;
const int NIL = -1;
const int INF = numeric_limits<int>::max();

struct Edge
{
    int nod;
    int urm;
    int capacity;
};

Edge G[2 * Mmax];
int head[Nmax];

int coada[Nmax];
int tata[Nmax];
int pointer[Nmax];

int N, M, contor;

void addEdge(int x, int y, int c)
{
    G[contor].nod = y;
    G[contor].capacity = c;
    G[contor].urm = head[x];
    head[x] = contor;

    contor++;
}

bool BFS(int S, int T)
{
    for ( int i = 1; i <= N; ++i )
        tata[i] = 0;

    tata[S] = S;

    int st = 1, dr = 1;
    coada[1] = S;

    while (st <= dr)
    {
        int nod = coada[st++];

        for ( int p = head[nod]; p != NIL; p = G[p].urm )
        {
            int son = G[p].nod;

            if (tata[son] == 0 && G[p].capacity)
            {
                assert(G[p].capacity > 0);

                tata[son] = nod;
                pointer[son] = p;
                coada[++dr] = son;

                if ( son == T )
                    return true;
            }
        }
    }

    return false;
}

int Edmonds_Karp(int S, int T)
{
    int flow = 0, fmin, nod;

    while ( BFS(S, T) )
    {
        for ( int p = head[T]; p != NIL; p = G[p].urm )
        {
            int son = G[p].nod;

            if (tata[son] != 0 && G[p ^ 1].capacity)
            {
                tata[T] = son;
                pointer[T] = p ^ 1;

                fmin = INF;
                nod = T;

                while (nod != S)
                {
                    fmin = min(fmin, G[ pointer[nod] ].capacity);
                    nod = tata[nod];
                }

                nod = T;

                while (nod != S)
                {
                    G[ pointer[nod] ].capacity -= fmin;
                    G[ pointer[nod] ^ 1 ].capacity += fmin;
                    nod = tata[nod];
                }

                flow += fmin;
            }
        }
    }

    return flow;
}

int main()
{
    FILE *in = fopen("maxflow.in", "r");
    FILE *out = fopen("maxflow.out", "w");

    fscanf(in, "%d %d", &N, &M);

    for ( int i = 1; i <= N; ++i )
        head[i] = NIL;

    for ( int i = 1; i <= M; ++i )
    {
        int a, b, c;
        fscanf(in, "%d %d %d", &a, &b, &c);

        addEdge(a, b, c);
        addEdge(b, a, 0);
    }

    fprintf(out, "%d\n", Edmonds_Karp(1, N));

    return 0;
}