// Vom explica fluxul ca fiind o retea de trinsport ( sa zicem ceva tevi )
// Fiecare teava are o capacitate data , nepund sa curga mai multa apa prin
// teava respectiva. Tu trebuie sa intuiesti mersul apei. Pesupund ca apa curge 
// intr-un minut din punctul de start la cel tina , cata apa ajunge la final
// pe minut. 
// Ca si graf , se poate intui ca graful este unidirectional. Exemplu:
//
// Start -> A ( maxim 3 ) -> C( maxim 3 ) |
//  	 -> B ( maxim 1 ) |-> C( maxim 5 )| -> End ( maxim 2 )
//         	              |-> D( maxim 4 ) -> E( maxim 2 ) -> End ( maxim 3 )
//	REZULTAT : 3;
// 
// Consideram tevile ca fiind bidirectionale , capacitatile pundau-se modifica
// pe parcursul algoritmului. Initial arcele de forma y -> x au capacitate 0
// Daca trece o catitate de apa prin teava x -> y , atunci Cap[x][y]-=c.
// Daca capacitate intr-o parte scade , atunci capacitate opusa crest Cap[y][x]+=c
// Bazandu-ne pe aceasta observatie la fiecare pas vom contrui arborele BFS si ne
// vom opri doar cand nu se mai poate ajunge la punctul tinta prin BFS.
// La fiecare pas trimite flux de la Start la nodurile legate de End. 
// ( in exemplu C si E )
// Consecitele fiecarui pas sunt modifcarile arborelui BFS din cauza fluctuatiei 
// capacitatii muchiilor. 
// In final Complexitatea este O(N*M*M) amortizat

#include <fstream>
#include <vector>
#include <cstring>
using namespace std;

const int Nmax=1011;
const int Mmax=5011;
const int oo=0x3f3f3f3f;

int Cap[Nmax][Nmax];
int Flew[Nmax][Nmax];
int Dad[Nmax],Marked[Nmax];
vector<int> Leg[Nmax];
int N,M,Flux,Fmin;

ifstream F("maxflow.in");
ofstream G("maxflow.out");

int Stiva[Nmax];

int BF()
{
	int i, j, nod, V;

	Stiva[0] = 1;
	Stiva[1] = 1;
	memset(Marked, 0, sizeof(Marked));
	Marked[1] = 1;

	for (i = 1; i <= Stiva[0]; i++)
	{
		nod = Stiva[i];
		if (nod == N) continue;
		
		for (j = 0; j < int(Leg[nod].size()) ; j++) 
			{
				V = Leg[nod][j];
				if ( Cap[nod][V]==Flew[nod][V] || Marked[V]) continue;
				Marked[V] = 1;
				Stiva[ ++Stiva[0] ] = V;
				Dad[V] = nod;
			}
	}

	return Marked[N];
}

int main()
{
	F>>N>>M;
	for (int i=1,x,y,z;i<=M;++i)
	{	
		F>>x>>y>>z;
		Cap[x][y]=z;
		Cap[y][x]=0;
		Leg[x].push_back( y );
		Leg[y].push_back( x );
	}
	
	while ( BF() )
		for (int i=0; i < int(Leg[N].size()) ; ++i)
		{
			int Nod=Leg[N][i];
			
			if ( Cap[Nod] == Flew[Nod] || !Marked[Nod] ) continue;
			
			Dad[N]=Nod;
			Fmin=oo;
			
			for (int Act=N; Act!=1; Act=Dad[Act] ) 
				Fmin=min( Fmin, Cap[ Dad[Act] ][Act] - Flew[ Dad[Act] ][Act]);
			if ( Fmin == 0 ) continue;
			
			for (int Act = N; Act != 1; Act = Dad[Act])
			{
				Flew[ Dad[Act] ][Act] += Fmin;
				Flew[Act][ Dad[Act] ] -= Fmin;
			}
			
			Flux+=Fmin;
		}

	G<<Flux<<'\n';
}