#include <queue>
#include <iostream>
#include <cstdio>
#include <bitset>
#include <climits>
#include <algorithm>
using namespace std;

const int MAXN = 1005;
const int INF = INT_MAX;

int n, m, x, y, c;
int capacity[MAXN][MAXN];
int flow[MAXN][MAXN];
int level[MAXN];
int current[MAXN];
int source, destination;

vector<int> adj[MAXN];

void addEdge(int u, int v, int w) {
    adj[u].push_back(v);
    capacity[u][v] = w;
}

bool bfs() {
    fill(level, level + MAXN, -1);
    level[source] = 0;
    queue<int> q;
    q.push(source);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        for(int v : adj[u]) {
            if(level[v] < 0 && flow[u][v] < capacity[u][v]) {
                level[v] = level[u] + 1;
                q.push(v);
            }
        }
    }
    return level[destination] > 0;

}
int dfs(int u, int t, int f) {
    if(u == t) return f;
    int pushed = 0;
    for(int &i = current[u]; i < adj[u].size(); i++) {
        int v = adj[u][i];
        if(level[v] == level[u] + 1 && flow[u][v] < capacity[u][v]) {
            int df = dfs(v, t, min(f, capacity[u][v] - flow[u][v]));
            if(df > 0) {
                flow[u][v] += df;
                flow[v][u] -= df;
                pushed += df;
                f -= df;
                if(f == 0) break;
            }
        }
    }
    return pushed;
}

int maxFlow() {
    int result = 0;
    while(bfs()) {
        fill(current, current + MAXN, 0);
        result += dfs(source, destination, INF);
    }
    return result;
}

int main() {
    freopen("maxflow.in", "r", stdin);
    freopen("maxflow.out", "w", stdout);

    scanf("%d%d", &n, &m);

    for (int i = 1; i <= m; i++ )
    {
        scanf("%d%d%d", &x, &y, &c);
        addEdge(x, y, c);
    }

    source = 1;
    destination = n;
    int max_flow = maxFlow();

    printf("%d", max_flow);
    return 0;
}