#include <bits/stdc++.h>
using namespace std;

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

int n, m;
vector<vector<int>>Adj;
vector<vector<int>>Adj_rev;
vector<vector<long>>flow;
vector<vector<long>>capacity;
vector<int>parent;
vector<int>vis;

bool bfs() {
    parent.assign(n+1, 0);
    vis.assign(n+1, 0);

    queue<int>q;
    int s=1;
    q.push(s);
    vis[s]=1;
    while (!q.empty()) {
        int u=q.front();
        q.pop();
        for (int &v:Adj[u]) {
            if (vis[v]==0 && capacity[u][v] - flow[u][v] > 0 ) {
                parent[v]=u;
                if (v == n)
                    return 1;
                q.push(v);
                vis[v]=1;
            }
        }
        for (int& v:Adj_rev[u]) {
            if (vis[v]==0 && flow[v][u] > 0 ) {
                parent[v]=-u;
                if (v == n)
                    return 1;
                q.push(v);
                vis[v]=1;
            }
        }
    }
    return 0;
}

long EdmondsKarp() {
    long maxflow=0;

    while (bfs()) {
        int t = n;
        long ip = 1100000;
        while (t!=1) {
            if (parent[t] > 0) {
                ip = min(ip, capacity[parent[t]][t] - flow[parent[t]][t]);
                t=parent[t];
            }
            else {
                ip = min(ip, flow[t][-parent[t]]);
                t=-parent[t];
            }
        }
        t = n;
        while (t!=1) {
            if (parent[t] > 0) {
                flow[parent[t]][t] += ip;
                t=parent[t];
            }
            else {
                flow[t][-parent[t]]-=ip;
                t=-parent[t];
            }
        }
        maxflow+=ip;
    }
    return maxflow;
}

int main() {
    fin>>n>>m;
    Adj.resize(n+1);
    Adj_rev.resize(n+1);
    flow.resize(n+1);
    capacity.resize(n+1);

    for (int i=1;i<=n;i++) {
        flow[i].assign(n+1, 0);
        capacity[i].assign(n+1, 0);
    }

    for (int i=1;i<=m;i++) {
        int x, y, c;
        fin>>x>>y>>c;
        Adj[x].push_back(y);
        Adj_rev[y].push_back(x);
        capacity[x][y] = c;
    }

   fout<<EdmondsKarp();


    return 0;
}