#pragma once


#include<iostream>
#include<vector>
#include<fstream>
#include<queue>
#include<algorithm>
#include<unordered_map>
#include<map>


using namespace std;

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

// Matrice de adiacenta : a[i][j] = cap de la i la j
// initial graful rezidual e initial matricea de adiacenta, cu a[i][j] = 0 daca nu exista muchie
// cand folosim muchia (i,j), facem a[i][j] -= flow, si a[j][i] += flow, e destul de logic
// o muchie e valabila daca a[i][j] > 0, si asta e logic



class Node {
public:
	vector<int> adj;
	void add(int id)
	{
		adj.push_back(id);
	}
};

vector<Node> nodes;

int graph[1001][1001], V, E, _inf = 1<<21;

int updatePath(vector<int> &parents) {

	// find bottleneck val
	int c = V, minim = _inf;
	while (parents[c] != 0) {
		if (graph[parents[c]][c] < minim)
			minim = graph[parents[c]][c];
		c = parents[c];
	}
	// update path
	c = V;
	while (parents[c] != 0) {
		graph[parents[c]][c] -= minim; // scadem din capacitatea muchiei pe care mergem
		graph[c][parents[c]] += minim; // crestem pe revers;
		c = parents[c];
	}

	return minim;
}

int augmentPath() {
	int found = 0;
	queue<int> q;
	vector<int> seen(V+1,0), parents(V+1,0);
	q.push(1);


	while (!q.empty()) {
		int c = q.front();
		q.pop();

		if (c == V) {
			found = 1;
			break;
		}

		seen[c] = 1;


		for (int v = 2; v <= V; v++) {

			if (seen[v] == 0 && graph[c][v] > 0) {
				seen[v] = 1;
				parents[v] = c;
				q.push(v);
			}

		}
	}

	if (found)
		return updatePath(parents);
	return 0;
}

int maxFlow() {
	int flow = 0, f;
	while ((f = augmentPath()) > 0)
		flow += f;
	return flow;
}

int main() {
	fin >> V >> E;

	int x, y, w;

	for (int i = 1; i <= E; i++) {
		fin >> x >> y >> w;
		graph[x][y] = w;
	}


	fout << maxFlow();

	return 0;

}