#include <fstream>
#include <vector>
#include <queue>
#include <iostream>
using namespace std;

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

//O(N*M^2)
//n - numarul de noduri
//m - numarul de muchii

int n, m, a, b, flow, graf[1001][1001], flux_max;
queue<pair<int, int>> q;
bool viz[1001];
int parent[1001];

int bfs(){
    while(!q.empty())
        q.pop();

    for(int i = 0; i <= n; i++){
        parent[i] = 0;
        viz[i] = false;
    }

    //in coada este retinut nodul si capacitatea
    q.push({1, 110001});
    viz[1] = true;

    while(!q.empty()){
        int nod = q.front().first;
        int flux = q.front().second;
        q.pop();

        //cautam care sunt vecinii nodului curent si vedem daca a fost vizitat
        //daca nu vedem care este fluxul minim pana la acel nod si il retinem
        //daca am ajuns la destinatie returnam fluxul
        for(int i = 1; i <= n; i++){
            if(!viz[i] && graf[nod][i] > 0){
                parent[i] = nod;
                viz[i] = true;

                int new_flux = min(flux, graf[nod][i]);
                if(i == n)
                    return new_flux;
                q.push({i, new_flux});
            }
        }
    }
    return 0;
}

int flux_maxim(){
    int flux = bfs();

    //daca am gasit un path atunci adunam fluxul la total si trecem prin path folosind vectorul de tati ca sa reconstruim graful
    while(flux){
        flux_max += flux;
        int nod_curent = n;

        while(nod_curent != 0){
            int prev = parent[nod_curent];
            graf[nod_curent][prev] += flux;
            graf[prev][nod_curent] -= flux;
            nod_curent = prev;
        }

        flux = bfs();
    }
    return flux_max;
}

int main(){
    fin >> n >> m;
    for(int i =  0; i < m; i ++){
        fin >> a >> b >> flow;
        graf[a][b] = flow;
    }
    fout << flux_maxim();
}