#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

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

int n, m;
vector<pair<int, int>> adj[1001];
vector<vector<int>> capacity(1001, vector<int>(1001, 0));

int maxflow()
{
    int source = 1;
    int sink = n;

    int flux = 0;
    while (true)
    {
        vector<int> parent(n + 1, -1);
        parent[source] = source;
        vector<int> flow(n + 1, 0);
        flow[source] = 1e9;

        // BFS
        vector<int> queue;
        queue.push_back(source);
        for (int i = 0; i < (int)queue.size(); i++)
        {
            int u = queue[i];
            for (auto &edge : adj[u])
            {
                int v = edge.first;
                int cap = capacity[u][v];
                if (parent[v] == -1 && cap > 0)
                {
                    parent[v] = u;
                    flow[v] = min(flow[u], cap);
                    queue.push_back(v);
                    if (v == sink)
                        break;
                }
            }
        }

        if (parent[sink] == -1)
            break; // nu am mai gasit cale catre destinatie

        // actual capacitatile
        int increment = flow[sink];
        flux += increment;
        int v = sink;
        while (v != source)
        {
            int u = parent[v];
            capacity[u][v] -= increment;
            capacity[v][u] += increment;
            v = u;
        }
    }
    return flux;
}

int main()
{
    fin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        fin >> a >> b >> c;
        adj[a].push_back({b, c});
        capacity[a][b] = c;
    }
    int result = maxflow();
    fout << result << "\n";
    return 0;
}