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

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

int n, m, x, y, capacitate;
vector<vector<int>> graf(1001, vector<int>(1001));
queue <int> coada;
vector<bool> vizitat(1001, false);
vector<int> parinte(1001);

bool bfs() {

    fill(vizitat.begin(), vizitat.end(), false);

    coada.push(1);
    vizitat[1] = true;

    while (!coada.empty()) {

        int nodCurent = coada.front();
        coada.pop();
        if(nodCurent == n) continue;

        for (int i = 1; i <= n; i++)
            if (!vizitat[i] && graf[nodCurent][i] > 0) {
                coada.push(i);
                vizitat[i] = true;
                parinte[i] = nodCurent;
            }
    }

    return vizitat[n];
}

int FluxMaxim() {

    int fluxMaxim = 0;

    fill(parinte.begin(), parinte.end(), 0);

    while (bfs()) {

        for(int i = 1; i < n; i++) {
            if(graf[i][n] > 0 && vizitat[i]) {
                int capacitateMinima = INT_MAX;
                int v = n;

                while (v != 1) {
                    capacitateMinima = min(capacitateMinima, graf[parinte[v]][v]);
                    v = parinte[v];
                }

                if (capacitateMinima == 0) continue;

                fluxMaxim += capacitateMinima;

                v = n;
                while (v != 1) {
                    int u = parinte[v];
                    graf[u][v] -= capacitateMinima;
                    graf[v][u] += capacitateMinima;
                    v = parinte[v];
                }
            }
        }
    }

    return fluxMaxim;
}

int main()
{
    f >> n >> m;

    for(int i = 0; i < m; i++) {
        f >> x >> y >> capacitate;
        graf[x][y] = capacitate;
    }

    f.close();

    g << FluxMaxim();
    g.close();
    return 0;
}