// 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>
using namespace std;

const int Nmax=1011;
const int Mmax=5011;
const int oo=1<<30;

typedef vector<int>::iterator Iter;

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

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

void Get( int Nod )
{
	Marked[Nod]=1;
	if ( Nod==N ) return;
	
	for (Iter it=Leg[Nod].begin();it!=Leg[Nod].end();++it)
		if ( !Marked[*it] && Cap[Nod][*it] )
		{
			Dad[ *it ]=Nod;
			Get( *it );
		}
}

int BF()
{
	for (int i=1;i<=N;++i) Marked[i]=Dad[i]=0;
	
	Get( 1 );
	
	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 (Iter Nod=Leg[N].begin();Nod!=Leg[N].end();++Nod)
		{
			if ( Cap[*Nod] == 0 || !Marked[*Nod] ) continue;
			
			Dad[N]=*Nod;
			Fmin=oo;
			
			for (int Act=N; Act!=1; Act=Dad[Act] ) 
				Fmin=min( Fmin, Cap[ Dad[Act] ][Act] );
			if ( Fmin == 0 ) continue;
			
			for (int Act = N; Act != 1; Act = Dad[Act])
			{
				Cap[ Dad[Act] ][Act] -= Fmin;
				Cap[Act][ Dad[Act] ] += Fmin;
			}
			
			Flux+=Fmin;
		}

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