#include <fstream>
#include <unordered_set>
#include <iostream>
#include <limits.h>
#include <string.h>
#include <queue>
#include <map>
#include <vector>

#define MAX 999999
using namespace std;

int c[1000][1000];
map<int, unordered_set<int>> nodes;


int main()
{
	memset(c, 0, sizeof(c));
	ifstream in;
	in.open("maxflow.in", ios::in);
	int n, m, u, v, source, dest;
	in >> n >> m;
	source = 0;
	dest = n - 1;
	for (int i = 0; i < m; i++)
	{
		in >> u >> v;
		u--;
		v--;
		nodes[u].insert(v);
		//nodes[v].insert(u);
		in >> c[u][v];
	}
	in.close();
	unordered_set<int> visited;
	int parent[1000];
	long max_flow = 0;

	for (;;)
	{
		memset(parent, 0, sizeof(parent));
		parent[source] = -1;
		visited.clear();
		visited.insert(source);
		queue<int> q;
		q.push(source);

		while (visited.find(dest) == visited.end() && !q.empty())
		{
			int nod = q.front();
			q.pop();
			for (unordered_set<int>::const_iterator it = nodes[nod].begin(); it != nodes[nod].end(); it++)
			{
				if (visited.find(*it) == visited.end() && c[nod][*it])
				{
					parent[*it] = nod;
					visited.insert(*it);
					q.push(*it);
				}
				if (visited.find(dest) != visited.end())
					break;
			}
		}

		if (visited.find(dest) == visited.end())
			break;

		int min_f = MAX;
		for (v = dest; v != source; v = parent[v])
		{
			u = parent[v];
			if (c[u][v] < min_f)
				min_f = c[u][v];
		}

		max_flow = max_flow + min_f;

		for (v = dest; v != source; v = parent[v])
		{
			u = parent[v];
			c[u][v] = c[u][v] - min_f;
			if (c[u][v] <= 0)
				nodes[u].erase(v);
			c[v][u] = c[v][u] - min_f;
			if (c[v][u] > 0)
				nodes[v].insert(u);
		}
	}

	ofstream out("maxflow.out", ios::out);
	out << max_flow;
	out.close();
	return 0;
}