#include <bits/stdc++.h>
#define oo 1e9
int n, t;

using namespace std;
vector<int> level, ptr;
vector<vector<int>> cap;
vector<vector<int>> flow;

int dfs (int u, int pushed) {
    if (pushed == 0) return 0;
    if (u == t) return pushed;
    for (int &cid = ptr[u]; cid < n; cid++) {
        int v = cid;
        if (level[v] == level[u] + 1 && cap[u][v] - flow[u][v] > 0) {
            int tr = dfs(v, min(pushed, cap[u][v] - flow[u][v]));
            if (tr == 0) continue;
            flow[u][v] += tr;
            flow[v][u] -= tr;
            return tr;
        }
    }
    return 0;
};

bool bfs(int s) {
    fill(level.begin(), level.end(), -1);
    queue<int> q;
    q.push(s);
    level[s] = 0;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v = 0; v < n; v++) {
            if (level[v] == -1 && cap[u][v] - flow[u][v] > 0) {
                level[v] = level[u] + 1;
                q.push(v);
            }
        }
    }
    return level[t] != -1;
};

int Dinic(int s) {

    level.assign(n, 0);
    ptr.assign(n, 0);
    queue<int> q;
    int f = 0;
    while (true) {
        fill(level.begin(), level.end(), -1);
        q.push(s);
        level[s] = 0;
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (int v = 0; v < n; v++) {
                if (level[v] == -1 && cap[u][v] - flow[u][v] > 0) {
                    level[v] = level[u] + 1;
                    q.push(v);
                }
            }
        }
        if(level[t] == -1) break;
        ptr.assign(n, 0);
        while (int pushed = dfs(s, oo)) {
            f += pushed;
        }
    }
    return f;
}

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

int main() {
    int m;
    fin >> n >> m;
    cap.assign(n, vector<int>(n));
    flow.assign(n, vector<int>(n));
    for(int i = 0; i < m; i++){
        int x, y, c;
        fin >> x >> y >> c;
        x--; y--;
        cap[x][y] += c;

    }
    t  = n-1;
    fout<<Dinic(0);
    return 0;
}