#include <iostream>
#include <vector>
#include <climits>
#include <queue>
#include <fstream>
#include <cstring>
#define VMAX 1001

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()
{
    queue <int> q;

    memset(parent, 0, sizeof(parent));

    q.push(1);
    parent[1] = -1;

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

        if (u != V)
        for (auto w:adj[u])
            if (!parent[w] && flow[u][w])
            {
                q.push(w);
                parent[w] = u;
            }
    }

    return parent[V] != 0;
}

int edmondKarp()
{
    int max_flow = 0;

    while (BFS())
        for (auto w:adj[V])
            if (parent[w] != 0 && flow[w][V])
            {
                parent[V] = w;

                int path_flow = INT_MAX;

                for (int u = V; u != 1; u = parent[u])
                    if (flow[parent[u]][u] < path_flow) path_flow = flow[parent[u]][u];

                if (!path_flow) continue;

                for (int u = V; u != 1; 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 >> flow[x][y];
        adj[x].push_back(y);
        adj[y].push_back(x);
    }

    int src = 1, sink = V;

    fout << edmondKarp();

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