/*
 * Flux maxim -> Ford-Fulkerson 
 * Implementare: Nechifor Eduard-Andrei
 * O(|E|*MF), unde MF = MaxFlow
 * Facultatea de Matematica si Informatica UBB : 215/1
 * Ar trebui sa obtina cam 60p pe infoarena
 */

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

using namespace std;

/*
 *File
 */
ifstream in("maxflow.in");
ofstream out("maxflow.out");

const int nMax = 1001;

/*
 * GrafR : graful rezidual
 * Coada pentru bfs
 * Vector de vizitati pt bfs
 * MaxFlow -> raspunsul
 * nrMuchii, nrNoduri din graf
 * parent -> vectorul de parinti
 */
int grafR[nMax][nMax];
queue<int>q;
bool vizitat[nMax];
int maxFlow;
int nrMuchii, nrNoduri;
int parent[nMax];

/*
 *Citirea grafului
 */

void read() {
	in >> nrNoduri >> nrMuchii;
	for (int m = 0; m < nrMuchii; m++) {
		int i, j, c;
		in >> i >> j >> c;
		grafR[i][j] = c;
	}
	return;
}

/*
 * Bfs ul
 * Sursa -> nodul sursa
 * Destinatie -> nodul destinatie
 */

bool bfs(int sursa, int destinatie) {

	/*
	 * Golim datele precedente
	 */
	for (int i = 1; i <= nrNoduri; i++) {
		vizitat[i] = parent[i] = 0;
	}

	q.push(sursa);
	vizitat[sursa] = 0;
	parent[sursa] = -1;

	while (q.empty() == false) {

		int nod = q.front();
		q.pop();
		for (int vecin = 1; vecin <= nrNoduri; vecin++) {
			if (!vizitat[vecin] && grafR[nod][vecin] > 0) {
				q.push(vecin);
				vizitat[vecin] = true;
				parent[vecin] = nod;
			}
		}
	}
	return (vizitat[destinatie]);
}

void fordFulkerson(int sursa, int destinatie) {

	while (bfs(1, nrNoduri)) {

		int minim = 1e9;
		for (int i = destinatie; i != sursa; i = parent[i]) {
			int parinte = parent[i];
			if (minim > grafR[parinte][i]) {
				minim = grafR[parinte][i];
			}
		}

		for (int i = destinatie; i != sursa; i = parent[i]) {
			int parinte = parent[i];
			grafR[parinte][i] -= minim;
			grafR[i][parinte] += minim;
		}
		maxFlow += minim;
	}

	return;
}

int main() {
	
	read();
	fordFulkerson(1, nrNoduri);
	out << maxFlow;

	return 0;
}