#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>

#define MAX 1005

using namespace std;

typedef struct {
	int f, d;
} Edge;

typedef struct {
	vector < vector <Edge> > E;
} Graph; 

int N, M;
Graph G;
bool visited[MAX];
int previous[MAX];
int pflow[MAX];
int maxf;

void read () {
	scanf("%d %d", &N, &M);
	
	G.E.resize(N+1);
	
	for (int i = 0; i < M; ++i) {
		int x;
		Edge e;
		
		scanf("%d %d %d", &x, &e.d, &e.f);
		
		G.E[x].push_back(e);
	}
}

int bfs () {
	memset(visited, false, (N+1) * sizeof(bool));

	queue <int> Q;
	Q.push(1);
	visited[1] = true;
	
	while (!Q.empty()) {
		int x = Q.front();
		vector <Edge>::iterator it;
		for (it = G.E[x].begin(); it != G.E[x].end(); ++it) {
			if (!visited[it->d]) {
				previous[it->d] = x;
				pflow[it->d] = it->f;
				visited[it->d] = true;
				
				if (it->d == N) {
					x = N;
					int min = 99999;
					while (x != 1) {
						if (pflow[x] < min) min = pflow[x];
						x = previous[x];
					}
					
					return min;
				}
				
				Q.push(it->d);
			}
		}
		Q.pop();
	}
	
	return 0;
}	

void maxflow() {
	int min = bfs();
	while (min != 0) {
		maxf += min;
		int x = N;
		while (x != 1) {
			vector <Edge>::iterator it;
			for (it = G.E[x].begin(); it != G.E[x].end(); ++it) {
				if (it->d == previous[x]) break;
			}
			
			if ((it != G.E[x].end())  && it->d == previous[x]) {
				it->f += min;
			} else {
				Edge aux = {previous[x], min};
				G.E[x].push_back(aux);
			}
			
			for (it = G.E[previous[x]].begin(); it != G.E[previous[x]].end(); ++it) {
				if (it->d == x) break;
			}
			
			it->f -= min;
			if (it->f == 0) {
				G.E[previous[x]].erase(it);
			}
			x = previous[x];
		}
		min = bfs();
	}
}
		
		

int main (void) {
	freopen("maxflow.in", "r", stdin);
	freopen("maxflow.out", "w", stdout);
	
	read();
	maxflow();
	printf("%d", maxf);
	return 0;
}