#include <fstream>
#include <vector>
#include <bitset>
#include <deque>
#define DEF 1010

using namespace std;

ifstream fin ("maxflow.in");
ofstream fout ("maxflow.out");

int n, m, sol, F[DEF][DEF], C[DEF][DEF], T[DEF];

vector < int > L[DEF];

bitset < DEF > Viz;

bool bfs () {

    bool ok = false;

    Viz.reset ();

    Viz[1] = 1;

    deque < int > q;
    q.push_back (1);

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

        for (int i = 0; i < L[nod].size (); ++ i) {
            int vecin = L[nod][i];
            if (Viz[vecin] == 0 and C[nod][vecin] > F[nod][vecin]) {
                q.push_back (vecin);
                Viz[vecin] = 1;
                T[vecin] = nod;
                if (vecin == n) {
                    ok = true;
                }
            }
        }

        q.pop_front ();
    }

    return ok;

}


int main () {

    fin >> n >> m;
    for (int i = 1; i <= m; ++ i) {
        int x, y, z;
        fin >> x >> y >> z;
        L[x].push_back (y);
        L[y].push_back (x);
        C[x][y] = z;
    }

    while (bfs ()) {

        for (int i = 0; i < L[n].size (); ++ i) {
            int vecin = L[n][i];
            if (C[vecin][n] > F[vecin][n] and Viz[vecin] == 1) {
                int Min = C[vecin][n] - F[vecin][n];
                while (T[vecin] != 0) {
                    Min = min (Min, C[T[vecin]][vecin] - F[T[vecin]][vecin]);
                    vecin = T[vecin];
                }

                sol += Min;

                vecin = L[n][i];
                F[vecin][n] += Min;
                F[n][vecin] -= Min;

                while (T[vecin] != 0) {
                    F[T[vecin]][vecin] += Min;
                    F[vecin][T[vecin]] -= Min;
                    vecin = T[vecin];
                }
            }
        }

    }

    fout << sol;

    return 0;
}