#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, vector<int>> nodes;


int main()
{
	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].push_back(v);
		nodes[v].push_back(u);
		in >> c[u][v];
	}
	in.close();
	//unordered_set<int> visited;
	bool visited[1000];
	int parent[1000];
	long max_flow = 0;

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

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

		if (!visited[dest])
			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;
			c[v][u] = c[v][u] + min_f;
		}
	}

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