///Flux maxim
///O retea de transport este un graf orientat in care fiecare muchie are asociata o capacitate si o anumita cantitate de flux. Fluxul primit de fiecare muchie trebuie sa fie mai mic sau egal decat capacitatea acesteia. De asemenea, pentru fiecare nod, fluxul care intra in nod trebuie sa fie egal cu cantitatea de flux care iese din nod. Cu alte cuvinte, suma fluxurilor asociate muchiilor care intra intr-un nod trebuie sa fie egala cu suma fluxurilor asociate muchiilor care ies din nod, exceptie facand nodurile speciale S si D, denumite sursa, respectiv, destinatie. Din nodul sursa poate doar iesi flux, in timp ce in nodul destinatie poate doar intra flux. Valoarea fluxului unei astfel retele este egal cu suma fluxului care iese din sursa sau cu suma fluxului care intra in destinatie (cele doua fluxuri sunt egale).
///Fisierul de intrare maxflow.in va contine pe prima linie 2 numere, N si M, reprezentand numarul de noduri si numarul de muchii din retea. Pe fiecare din urmatoarele M linii, se vor afla cate 3 numere naturale, x, y si z, cu semnificatia ca exista o muchie care porneste de la nodul x, ajunge in nodul y si are capacitatea z.
///2 ≤ N ≤ 1 000
//1 ≤ M ≤ 5 000
//Nodul 1 este nodul sursa, iar nodul N este nodul destinatie.
//Pentru fiecare muchie, capacitatea va fi un numar natural in intervalul [1, 110 000].
//Nu exista nici o muchie x y astfel incat x sa fie egal cu N sau y sa fie egal cu 1.
//Intre oricare doua noduri x si y exista maxim un arc, însă arcele x -> y şi y -> x pot exista simultan.
//In practica, retelele de flux contin adesea un numar mare de noduri vecine cu destinatia. Testele folosite la evaluarea vitezei algoritmului de flux de la aceasta problema au aceeasi proprietate.

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

ifstream f("maxflow.in");
ofstream g("maxflow.out");

const int NMAX = 1005;
const int MMAX = 5005;

int n, m;
int graf[NMAX][NMAX];
int grafrez[NMAX][NMAX];
int flux[NMAX][NMAX];
int tata[NMAX];

int main() {
    f>>n>>m;
    for(int i = 1; i <= m; i++) {
        int x, y, z;
        f>>x>>y>>z;
        graf[x][y] = z;
    }
    int fluxmax = 0;
    while(true) {
        for(int i = 1; i <= n; i++) {
            tata[i] = 0;
        }
        queue<int> q;
        q.push(1);
        tata[1] = -1;
        while(!q.empty()) {
            int nod = q.front();
            q.pop();
            for(int i = 1; i <= n; i++) {
                if(tata[i] == 0 && graf[nod][i] - flux[nod][i] > 0) {
                    tata[i] = nod;
                    q.push(i);
                }
            }
        }
        if(tata[n] == 0) {
            break;
        }
        int fluxcurent = 110001;
        for(int i = n; i != 1; i = tata[i]) {
            fluxcurent = min(fluxcurent, graf[tata[i]][i] - flux[tata[i]][i]);
        }
        for(int i = n; i != 1; i = tata[i]) {
            flux[tata[i]][i] += fluxcurent;
            flux[i][tata[i]] -= fluxcurent;
        }
        fluxmax += fluxcurent;
    }
    g<<fluxmax<<'\n';
    return 0;
}