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

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

int n,m,i,flux,minim;

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

    memset(U, false, sizeof(U));
    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;
            }

            for(T[n] = *it, minim = INF, i = n; T[i]; i = T[i])
                minim= min( minim, C[T[i]][i] - F[T[i]][i]);

            for (i = n; T[i]; i = T[i]) {
                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;
}