#include <bits/stdc++.h>
 
using namespace std;
 
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
 
struct MaxFlow {
    int source, destination, N;
    vector < int > parent;
    vector < vector < int > > G, residual;

    MaxFlow() {}
    MaxFlow(int _N) : N(_N), parent(_N), G(_N), residual(_N) {
        for (auto &it: residual) {
            it.resize(_N);
        }
    }

    void addEdge(int a, int b, int cap) {
        G[a].push_back(b);
        G[b].push_back(a);
        residual[a][b] += cap;
    }

    bool BFS() {
        parent.assign(N, -1);
        queue < int > Q;

        parent[source] = -2;
        Q.push(source);
        while (!Q.empty()) {
            int node = Q.front();
            Q.pop();

            for (auto x: G[node]) {
                if (parent[x] == -1 && residual[node][x]) {
                    Q.push(x);
                    parent[x] = node;
                }
            }
        }

        return parent[destination] != -1;
    }

    int getMaxFlow() {
        int totalFlow = 0;

        while (BFS()) {
            for (auto x: G[destination]) {
                if (parent[x] == -1) continue;

                int maxFlow = residual[x][destination];
                for (int now = x; now != 0; now = parent[now]) {
                    int prev = parent[now];
                    maxFlow = min(maxFlow, residual[prev][now]);
                }

                residual[x][destination] -= maxFlow; residual[destination][x] += maxFlow;
                for (int now = x; now != 0; now = parent[now]) {
                    int prev = parent[now];
                    residual[prev][now] -= maxFlow;
                    residual[now][prev] += maxFlow;
                }

                totalFlow += maxFlow;
            }
        }

        return totalFlow;
    }
};

int main() {
    ios::sync_with_stdio(false);
    
    int n, m;
    fin >> n >> m;

    MaxFlow ek(n);
    for (int i = 0; i < m; ++i) {
        int a, b, cap;
        fin >> a >> b >> cap;

        ek.addEdge(a - 1, b - 1, cap);
    }

    ek.source = 0;
    ek.destination = n - 1;
    fout << ek.getMaxFlow();
    return 0;
}