#include <bits/stdc++.h>
    #include <fstream>

    using namespace std;

    const int MAXN = 1000;

    vector<int> G[MAXN + 1];
    unordered_map<int, unordered_map<int, int>> capacity, flow; // O(E)
    int N, M;

    void readInput() {
        ifstream f("maxflow.in");
        f >> N >> M;
        for (int i = 0; i < M; i++) {
            int x, y, c;
            f >> x >> y >> c;
            G[x].push_back(y);
            G[y].push_back(x);
            capacity[x][y] += c;
        }
        f.close();
    }

    bool bfs(int source, int sink, vector<int>& parent, vector<bool>& visited) {
        fill(visited.begin(), visited.end(), false);
        fill(parent.begin(), parent.end(), -1);

        queue<int> q;
        q.push(source);
        visited[source] = true;

        while (!q.empty()) {
            int u = q.front(); q.pop();
            if (u == sink) continue;

            for (int v : G[u]) {
                if (!visited[v] && capacity[u][v] - flow[u][v] > 0) {
                    visited[v] = true;
                    parent[v] = u;
                    q.push(v);
                }
            }
        }
        return visited[sink];
    }

    int EdmondsKarpOptimizat(int source, int sink) {
        int maxFlow = 0;
        vector<int> parent(N + 1);
        vector<bool> visited(N + 1);

        while (bfs(source, sink, parent, visited)) {

            for (int v : G[sink]) {
                if (!visited[v]) continue;
                if (capacity[v][sink] - flow[v][sink] <= 0) continue;

                parent[sink] = v;

                int add = INT_MAX;
                for (int u = sink; u != source; u = parent[u]) {
                    int p = parent[u];
                    add = min(add, capacity[p][u] - flow[p][u]);
                }

                if (add == 0) continue;

                for (int u = sink; u != source; u = parent[u]) {
                    int p = parent[u];
                    flow[p][u] += add;
                    flow[u][p] -= add;
                }

                maxFlow += add;
            }
        }
        return maxFlow;
    }

    int main() {
        readInput();

        ofstream g("maxflow.out");
        g << EdmondsKarpOptimizat(1, N);
        g.close();

        return 0;
    }