#include <iostream>
#include <fstream>
#include <cstring>
#include <queue>
#include <vector>
#include <algorithm>

using namespace std;

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

vector<int> graph[10000];
queue<int> q;

int c[10000][10000];
int f[10000][10000];
int parent[100000];
int n,m,x,y,z,s,d,fMax;

vector<unsigned int> BFS(int s,int d) {
	vector<unsigned int> path;
	unsigned int node;

	q.push(s);

	memset(parent,-1,sizeof(parent));
	while (!q.empty()) {
		node=q.front();

		for (unsigned int i=0;i<graph[node].size();i++) {
			if ((c[node][graph[node][i]]-f[node][graph[node][i]])>0 && parent[graph[node][i]]==-1) {
				parent[graph[node][i]]=node;
				q.push(graph[node][i]);
			}
		}

		q.pop();
	}

	if (parent[d]==-1) {
		return vector<unsigned int>();
	}

	for (node=d;true;node=parent[node]) {
		path.push_back(node);
		if (node==s) 
			break;
	}

	reverse(path.begin(),path.end());

	return path;
}

void EdmondsKarp(int s,int d) {
	int flow=0;

	while (true) {
		vector<unsigned int> path=BFS(s,d);

		if (path.size()<2) {
			return;
		}

		flow=c[path[0]][path[1]]-f[path[0]][path[1]];
		for (unsigned int i=0;i<path.size()-1;i++) {
			if ((c[path[i]][path[i+1]]-f[path[i]][path[i+1]])<flow) {
				flow=c[path[i]][path[i+1]]-f[path[i]][path[i+1]];
			}
		}

		if (flow==0) {
			break;
		}

		fMax+=flow;

		for (unsigned int i=0;i<path.size()-1;i++) {			
			f[path[i]][path[i+1]]+=flow;
			f[path[i+1]][path[i]]-=flow;
		}
	}
} 

int main() {
	in>>n>>m;
	
	for (int i=1;i<=m;i++) {
		in>>x>>y>>z;
		graph[x].push_back(y);
		c[x][y]=z;
	}

	EdmondsKarp(1,n);

	out<<fMax;

	return 0;
}