// Edmonds-Karp
// "Optimizarea" de 100p merge doar cand intra mai multe muchii in sink, altfel nu face nimic...
#include <bits/stdc++.h>
#define ll long long

using namespace std;

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

struct Edge {
    int from;
    int to;
    int cap;
    int flow; 
};

struct EKMaxFlow {
    int source;
    int sink;
    vector<Edge> edges;
    vector<vector<pair<int, int> > > v;
    vector<int> path;
    vector<int> seen;
    int N;
    int M;

    EKMaxFlow(int s, int d, int n, int m) : source(s), sink(d), v(n), path(n), seen(n), N(n), M(m) {}

    void addEdge(int from, int to, int cap) {
        edges.push_back({from, to, cap, 0});
        v[from].push_back({to, (int) edges.size() - 1});
        edges.push_back({to, from, 0, 0});
        v[to].push_back({from, (int) edges.size() - 1});
    }

    bool canAugment() {
        queue<int> q;
        q.push(source);
        fill(seen.begin(), seen.end(), 0); 
        seen[source] = 1; 

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

            if (node == sink) {
                return true;
            }

            for (auto nxt : v[node]) {
                if (!seen[nxt.first]) {
                    int resCap = edges[nxt.second].cap - edges[nxt.second].flow; 
                
                    if (resCap > 0) {
                        seen[nxt.first] = 1;
                        q.push(nxt.first);
                        path[nxt.first] = nxt.second;
                    }
                }
            }
        }

        return false;
    }

    int maxFlow() {
        int flow = 0;

        while (canAugment()) {
            for (auto pv : v[sink]) {
                int mn = INT_MAX;
                int validPath = 1;

                for (int edgeId = pv.second ^ 1; ; edgeId = path[edges[edgeId].from]) {
                    int resCap = edges[edgeId].cap - edges[edgeId].flow;
                    mn = min(mn, resCap);
                    validPath &= seen[edges[edgeId].from];
                    
                    if (edges[edgeId].from == source) {
                        break;
                    }
                }

                if (!validPath) {
                    continue;
                }

                flow += mn;

                for (int edgeId = pv.second ^ 1; ; edgeId = path[edges[edgeId].from]) {
                    edges[edgeId].flow += mn;
                    edges[edgeId ^ 1].flow -= mn;
                    
                    if (edges[edgeId].from == source) {
                        break;
                    }
                }
            }
        }

        return flow; 
    }
};

int main() {
    int n, m;
    in >> n >> m;
    EKMaxFlow graph(0, n - 1, n, m);

    for (int i = 0, x, y, c; i < m; i++) {
        in >> x >> y >> c;
        x--;
        y--;
        graph.addEdge(x, y, c);
    }

    out << graph.maxFlow();

    return 0;
}