#include <bits/stdc++.h>
#include <limits>
using namespace std;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
int n, m, flow, flowMax = 0;
vector<int> viz;
vector<bool> parents(1005, false);
vector<vector<int>> graph, capacity;

bool bfs()
{
    parents.assign(n + 1, 0);
    viz.assign(n + 1, false);
    viz[1] = true;
    queue<int> coada;
    coada.push(1);
    while (!coada.empty())
    {
        int currentNode = coada.front();
        coada.pop();


        for (auto &neigbour : graph[currentNode])
        {
            if (viz[neigbour] || capacity[currentNode][neigbour] <= 0)
            {
                continue;
            }
            coada.push(neigbour);
            viz[neigbour] = true;
            parents[neigbour] = currentNode;
            if( neigbour == n)
            {
                return true;
            }

        }
    }
    return false;
}

int main()
{
    int node1, node2, cap;
    fin >> n >> m;

    graph.resize(n + 1);
    parents.resize(n + 1);
    capacity.resize(n + 1, vector<int>(n + 1, 0));

    for (int i = 1; i <= m; ++i)
    {
        fin >> node1 >> node2 >> cap;
        graph[node1].push_back(node2);
        graph[node2].push_back(node1);
        capacity[node1][node2] = cap;
    }

    while (bfs())
    {
        for (auto &neigh : graph[n])
        {
            if (viz[neigh] && capacity[neigh][n] > 0)
            {
                flow = capacity[neigh][n];
                int aux = neigh;


                while(parents[aux])
                {
                    flow = min(capacity[parents[aux]][aux], flow);
                    aux = parents[aux];
                }
                aux = neigh;
                capacity[neigh][n] -= flow;
                capacity[n][neigh] += flow;

                while(parents[aux])
                {
                    capacity[parents[aux]][aux] -= flow;
                    capacity[aux][parents[aux]] += flow;
                    aux = parents[aux];
                }
                flowMax += flow;
            }

        }
        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.
*/