#include <iostream>
#include <vector>
#include <climits>
#include <queue>
#include <fstream>
#define VMAX 1000

using namespace std;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

int V, E, x, y, cap, u;
vector <int> adj[VMAX]; // lista de adiacenta
int flow[VMAX][VMAX]; // fluxurile
int parent[VMAX]; // parinti pentru shortest paths

bool BFS(int src, int sink)
{
    queue <int> q;

    for (int i = 0; i < V; ++i) parent[i] = -1;

    q.push(src);
    parent[src] = -2;

    while (!q.empty())
    {
        u = q.front();
        q.pop();

        if (u == sink) continue;

        for (int v = 0; v < V; ++v)
            if (parent[v] == -1 && flow[u][v])
            {
                q.push(v);
                parent[v] = u;
            }
    }

    return parent[sink] != -1;
}

int edmondKarp(int src, int sink)
{
    int max_flow = 0;

    while (BFS(src, sink))
        for (auto w:adj[sink])
        {
            if (parent[w] == -1 || !flow[w][sink]) continue;

            parent[sink] = w;

            int path_flow = INT_MAX;

            for (int u = sink; u != src; u = parent[u])
                path_flow = min(path_flow, flow[parent[u]][u]);

            for (int u = sink; u != src; u = parent[u])
            {
                flow[parent[u]][u] -= path_flow;
                flow[u][parent[u]] += path_flow;
            }

            max_flow += path_flow;
        }

    return max_flow;
}

int main()
{
    fin >> V >> E;

    for (int i = 0; i < E; ++i)
    {
        fin >> x >> y >> cap;
        adj[x - 1].push_back(y - 1);
        adj[y - 1].push_back(x - 1);
        flow[x - 1][y - 1] = cap;
    }

    for (int i = 0; i < V; ++i) parent[i] = -1;

    int src = 0, sink = V - 1;

    fout << edmondKarp(src, sink);

    fin.close();
    fout.close();
    return 0;
}