#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#define MAXN 201
#define MAXE 1002
#define INF 0x3f3f3f3f
using namespace std;

vector<vector<int> > G;
queue<int> Q;
int C[MAXE][MAXE], F[MAXE][MAXE], T[MAXE];
bool U[MAXE];

int n,m,i,flux,fr,t,minim;

bool Bfs() {
    int p,u;
    bool ret;
    vector<int>::iterator it;

    vector<bool> U ( MAXN , false);
    Q.push(1);
    U[1] = true;
    ret = false;
    while (!Q.empty()) {
        for (it = G[Q.front()].begin(); it!=G[Q.front()].end(); it++) {
            if (U[*it]==false && C[Q.front()][*it]>F[Q.front()][*it]) {
                if (*it == n) {
                    ret = true;
                    continue;
                }
                Q.push(*it);
                U[*it] = true;
                T[*it] = Q.front();
            }
        }
        Q.pop();
    }

    return ret;
}


int main(){
    ifstream fin("maxflow.in");
    fin>>n>>m;
    int x,y,c;
    while(m--) {
        fin>>x>>y>>c;
        C[x][y] = c;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    fin.close();

    vector<int>::iterator it;
    flux = 0;
    while (Bfs()) {
        for (it = G[n].begin(); it!=G[n].end(); it++) {
            if (!U[*it] || C[*it][n] == F[*it][n]){
                continue;
            }

            T[n] = *it;
            for (minim = INF, i = n; T[i]; i = T[i]) {
                if (minim>C[T[i]][i] - F[T[i]][i])
                    minim = C[T[i]][i] - F[T[i]][i];
            }

            for (t = n; T[t]; t = T[t]) {
                F[T[i]][i]+=minim;
                F[i][T[i]]-=minim;
            }

            if (minim!=INF) {
                flux+=minim;
            }
        }
    }

    ofstream fout("maxflow.out");
    fout<<flux<<'\n';
    fout.close();

    return 0;
}