#include <fstream>
#include <vector>
#include <queue>
#include <bitset>
#define DIM 1010
using namespace std;

int C[DIM][DIM];
int F[DIM][DIM];
int T[DIM];
bitset<DIM> U;
vector<int> L[DIM];
deque<int> q;

int n, m, i, j, minim, flux, x, y, z, u;

int bfs() {
    // pornim din 1 si mergand pe muchii cu capacitate>flux
    // incercam sa vizitam pe n, construind totodata un vector de tati
    int gasit = 0;
    U.reset();

    U[1] = 1;
    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 (U[vecin] == 0 && C[nod][vecin] > F[nod][vecin]) {
                q.push_back(vecin);
                U[vecin] = 1;
                T[vecin] = nod;
                if (vecin == n) {
                    gasit = 1;
                }
            }
        }
        q.pop_front();
    }
    return gasit;
}

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

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

    while ( bfs() ) {
        // caut predecesorii p ai lui n care au fost vizitati
        // la parcurgerea curenta si pentru care C[p][n] > F[p][n]
        for (int i=0;i<L[n].size(); i++) {
            int vecin = L[n][i];
            if(U[vecin] == 1 && C[vecin][n] > F[vecin][n]) {
                minim = C[vecin][n] - F[vecin][n];
                for (u=vecin;T[u];u = T[u])
                    if (C[ T[u] ][u] - F[ T[u] ][u] < minim) {
                        minim = C[ T[u] ][u] - F[ T[u] ][u];
                    }
                if (minim == 0)
                    continue;

                flux += minim;

                F[vecin][n] += minim;
                F[n][vecin] -= minim;

                for (u=vecin;T[u];u = T[u]){
                    F[ T[u] ][u] += minim;
                    F[u][ T[u] ] -= minim;
                }
            }
        }

    }
    fout<<flux;
    return 0;
}