#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <string.h>

#define max 1001
#define infinity 1000000

using namespace std;
/* muchiile din graf */
vector < vector <int> > graph;
/* capacitatile muchiilor */
int C[max][max];
/* fluxul actual pe muchie */
int F[max][max];
/* vector de parinti 
 * folosit la bfs pt actualizarea capacitatilor reziduale */
int parents[max];

queue<int> before_target;

int path[max];
int N, M;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

void bfs(int source, int target){
	
	/* clear parents vector */
	memset(parents, -1, sizeof(parents));
	/* clear current path */
	memset(path, 0, sizeof(path));
	
	queue<int> q;
	parents[source] = -2;
	q.push(source);
	while(!q.empty()){
		int elem = q.front();
		q.pop();
		for(int i = 0; i < graph[elem].size(); i++){
			int u = graph[elem][i];
			if(C[elem][u] - F[elem][u] > 0 && parents[u] == -1){
				if(u == target) {
					before_target.push(elem);
				}else{
					parents[u] = elem;
					q.push(u);
				}
			}
		}
	}
}

int edmonds_karp(int source, int target){
	int max_flow = 0, back, minim;
	vector < pair < int, int> > rezid;
	while(true){
		bfs(source, target);
		if(before_target.size() == 0) break;
		while(!before_target.empty()){
			int elem = before_target.front();
			before_target.pop();
			parents[target] = elem;
			back = target;
			minim = infinity;
			/* intors pt minim */
			while(source != back){
				if(minim > C[parents[back]][back] - F[parents[back]][back]){
					minim = C[parents[back]][back] - F[parents[back]][back];
				}
				back = parents[back];
			}
			/* intors pt actualizare */
			back = target;
			while(source != back){
				F[parents[back]][back] += minim;
				F[back][parents[back]] -= minim;
				back = parents[back];
			}
			max_flow += minim;
		}
	}
	return max_flow;
}

int main(){
	int a, b, c;
	vector<int> v;
	fin >> N >> M;
	for(int i = 0; i < N; i++) 
		graph.push_back(v);
	for(int i = 0; i < M; i++){
		fin >> a >> b >> c;
		graph[--a].push_back(--b);
		graph[b].push_back(a);
		C[a][b] = c;
	}
	
	int max_flow = edmonds_karp(0,N-1);
	fout << max_flow << "\n";
	return 0;
}