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

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

// struct Muchie
// {
//     int nod;
//     int cost;
// };

int n, m;

vector<vector<int>> la;
vector<vector<int>> capacitate, flux;
vector<int> tata;

void Read()
{
    f >> n >> m;

    la.resize(n + 1);
    capacitate.resize(n + 1, vector<int>(n + 1, 0));
    flux.resize(n + 1, vector<int>(n + 1, 0));
    tata.resize(n + 1, 0);

    int x, y, z;
    for (int i = 1; i <= m; i++)
    {
        f >> x >> y >> z;
        la[x].push_back(y);
        la[y].push_back(x);
        capacitate[x][y] += z;
    }
}

bool ConstruiesteDrumBF()
{
    int nod;
    vector<bool> viz(n + 1, false);
    viz[1] = true;

    queue<int> q;
    q.push(1);
    while (!q.empty())
    {
        int nod_curent = q.front();
        q.pop();
        for (auto &vecin : la[nod_curent])
        {
            // daca vecinul este vizitat sau capacitatea este folosită la maxim sărim peste
            if (viz[vecin] || capacitate[nod_curent][vecin] == flux[nod_curent][vecin])
                continue;
            q.push(vecin);
            viz[vecin] = true;
            tata[vecin] = nod_curent;

            // dacă am ajuns la destinația finală
            if (vecin == n)
                return true;
        }
    }

    return false;
}

int main()
{
    Read();
    int flow = 0, fmin;

    while (ConstruiesteDrumBF())
    {
        fmin = INT_MAX;
        // aflam capacitatea reziduală minimă
        for (int nod = n; nod != 1; nod = tata[nod])
        {
            fmin = min(fmin, capacitate[tata[nod]][nod] - flux[tata[nod]][nod]);
        }

        // revizuim fluxul
        for (int nod = n; nod != 1; nod = tata[nod])
        {
            // actualizam pe muchiile directe
            flux[tata[nod]][nod] += fmin;

            // actualizam pe muchiile inverse
            flux[nod][tata[nod]] -= fmin;
        }

        flow += fmin;
    }

    g << flow;

    return 0;
}