#include <iostream>
#include <vector>
#include <list>
#define MAX_NODES 2500
#define INF 0x3fffffff
#define INFO_ARENA_IN 1
#define INFO_ARENA_OUT 1

using namespace std;

unsigned g[MAX_NODES][MAX_NODES];
unsigned n, m, 	pthfnd;

unsigned viz[MAX_NODES];
int prvNd[MAX_NODES];
unsigned queue[2 * MAX_NODES];




void read()
{
	cin>>n>>m;
	unsigned a, b, c;	
	for(unsigned i=0; i<m; ++i)
	{
		cin>>a>>b>>c;
		g[a-1][b-1] = c;		
	}
}

int dfs(int node)
{
	viz[node] = 1;
	
	if(node == n - 1)
	{
		return 1;
	}
	
	for(unsigned i=0; i<n; ++i)
	{
		if(g[node][i] && !viz[i])
		{
			prvNd[i] = node;
			if(dfs(i))
			{
				return 1;
			}
			else
			{
				continue;
			}
		}		
	}
	return 0;
}

int find_path()
{
	pthfnd = 0;

	memset(prvNd, -1, sizeof(prvNd));
	memset(viz, 0, sizeof(viz));
	
	unsigned minCap = INF, front, back;
	
	
	front = 0; 
	back = 1;

	
	queue[0] = 0;
	viz[0] = 1;
	
	/*
	while(front < back)
	{
		int node = queue[front];
		
		if(node == n-1)
		{
			break;
		}

		front++;	
		
		for(unsigned i=0; i<n; ++i)
		{
			if(g[node][i] && !viz[i])
			{
				viz[i] = 1;
				prvNd[i] = node;
				queue[back++] = i;		
			}
		}
	} */

	dfs(0);
	int node = n-1, prv;


	while( prvNd[node] >=0 )
	{
		prv = prvNd[node];
		minCap = min(minCap, g[prv][node]);
		node = prv;
	}

	node = n-1;

	while( prvNd[node] >=0 )
	{
		prv = prvNd[node];
		g[prv][node] -= minCap;
		g[node][prv] += minCap;
		node = prv;
	}
	if(minCap == INF)
	{
		pthfnd = 0;
		return 0;
	}
	else
	{
		pthfnd = 1;
		return minCap;
	}	
}

unsigned max_flow()
{
	int flow = 0, path_cap;
	while(true)
	{
		path_cap = find_path();
		if(!pthfnd)
		{
			return flow;
		}
		else
		{
			flow += path_cap;
		}
	}
}



int main ()
{
#if INFO_ARENA_IN
	freopen("maxflow.in", "rt", stdin);
#endif

#if INFO_ARENA_OUT
	freopen("maxflow.out", "wt", stdout);
#endif
	read();

	cout << max_flow() << endl;
	
	return 0;
}