#include <iostream>
#include <fstream>
#include <vector>
#include <utility>
#include <queue>
#include <limits.h>

using namespace std;

typedef vector< vector<int> > Graph;

#define CAPACITY second
#define NEGHBOR first
#define NMAX 1001

int F[NMAX][NMAX];
int C[NMAX][NMAX];

int path[NMAX];
int prev[NMAX];

bool bfs(Graph &graph, int n, int source, int dest) {
    vector<bool> visited(n + 1, false);
    queue<int> bfs_q;

    bfs_q.push(source);
    visited[source] = true;

    int node, next;
    while(!bfs_q.empty()) {
        node = bfs_q.front();
        bfs_q.pop();

        for (unsigned int i = 0; i < graph[node].size(); i++) {
            next = graph[node][i];
            if (C[node][next] > F[node][next] && !visited[next]) {
                visited[next] = true;
                bfs_q.push(next);
                prev[next] = node;
                if(next == dest)
                    return true;
            }
        }
    }
    return false;
}

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

    int n, m, fmin, total_flow = 0;
    fin >> n >> m;

    Graph graph(n + 1);
    vector<int> bfs_path;

    int v1, v2, capacity;
    for (int i = 1; i <= m; i++) {
        fin >> v1 >> v2 >> capacity;
        graph[v1].push_back(v2);
        graph[v2].push_back(v1);
        C[v1][v2] += capacity;
    }

    do {
        if(!bfs(graph, n, 1, n)) {
            break;
        }

        fmin = INT_MAX;
        for (int i = n; i != 1; i = prev[i]) {
            fmin = min(fmin, C[prev[i]][i] - F[prev[i]][i]);
        }

        for (int i = n; i != 1; i = prev[i]) {
            F[prev[i]][i] += fmin;
            F[i][prev[i]] -= fmin;
        }
        total_flow += fmin;
    } while (true);

    fout << total_flow;

    return 0;
}