#include <fstream>
#include <vector>
#include <queue>
#include <bits/stdc++.h>
using namespace std;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
int capacity[1001][1001], n, m, flow, flowMax;
vector<int> viz, parents;
vector<vector<int>> graph;

bool bfs()
{
    for (auto elem : viz)
    {
        elem = 0;
    }
    for (auto elem : parents)
    {
        elem = 0;
    }
    parents[1] = 1;
    viz[1] = 1;
    queue<int> coada;
    coada.push(1);
    while (!coada.empty())
    {
        int currentNode = coada.front();
        coada.pop();
        if (currentNode == n)
        {
            return true;
        }
        for (int i = 0; i < graph[currentNode].size(); ++i)
        {
            if (!viz[graph[currentNode][i]] && capacity[currentNode][graph[currentNode][i]] > 0)
            {
                coada.push(graph[currentNode][i]);
                parents[graph[currentNode][i]] = currentNode;
                viz[graph[currentNode][i]] = 1;
            }
        }
    }
    return false;
}

int main()
{
    int a, b, c;
    fin >> n >> m;
    viz.resize(n + 1, 0);
    parents.resize(n + 1, 0);
    graph.resize(n + 1, {});

    for (int i = 1; i <= m; ++i)
    {
        fin >> b >> c >> a;
        graph[b].push_back(c);
        graph[c].push_back(b);
        capacity[b][c] = a;
    }

    bool continueProgram = bfs();
    while (continueProgram)
    {
        for (int i = 0; i < graph[n].size(); ++i)
        {
            if (viz[graph[n][i]])
            {
                parents[n] = graph[n][i];
                flow = INT_MAX;
                for (int j = n; j != 1; j = parents[j])
                {
                    flow = min(flow, capacity[parents[j]][j]);
                }
                if (flow != 0)
                {
                    for (int j = n; j != 1; j = parents[j])
                    {
                        capacity[parents[j]][j] -= flow;
                        capacity[j][parents[j]] += flow;
                    }
                    flowMax += flow;
                }
            }
        }
        continueProgram = bfs();
    }
    fout << flowMax;
    return 0;
}

/***
Parcurgem graful din nodul radacina trecand prin muchii cu flux != 0. drumul e reconstruit folosind vectorii de noduri vizitate si de parinti.
Cu fiecare parcurgere se scade flow ul minim din toate muchiile drumului si se updateaza flow ul maxim.
*/