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

using namespace std;

#define INFINIT 999999999

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

//Implementare naiva Ford Fulkerson cu DFS - determinarea capacitatii totale de flux de la sursa la destinatie
//incepem aici cu graful gol

//logica algoritmului:
//cat timp exista drum cu capacitate ramasa de la S la D, saturam drumul cu valoarea bottleneck

//deci,trb sa determinam drum de la S la D, putem face cu DFS , care o sa parcurga tot graful si la D se opreste daca se poate ajunge (1 e sursa, N e destinatie)

//tinem minte matrice de capacitate si sa vedem ce facem cu arcele inverse

vector<bool> vizitat;
vector<vector<int>> vecini;

int capacitate[1001][1001];

int DFS(int nod_curent, int destinatie, int flux_de_trimis) {
	vizitat[nod_curent] = true;

	if (nod_curent == destinatie) return flux_de_trimis;

	for (auto v : vecini[nod_curent]) {
		if (!vizitat[v] && capacitate[nod_curent][v] != 0) {
			//facem DFS si vedem daca gasim flux

			int nou_flux_maxim = min(flux_de_trimis, capacitate[nod_curent][v]);

			int rez = DFS(v, destinatie, nou_flux_maxim);

			if (rez > 0) {
				//actualizam capacitatile
				capacitate[nod_curent][v] -= rez;
				capacitate[v][nod_curent] += rez; //adaugam capacitatea la muchia reziduala

				return rez; // returnam la parinti fluxul
			}
		}
	}

	return 0;
}


int main() {
	int n, m;
	fin >> n >> m;

	vecini.resize(n + 1);

	for (int i = 1; i <= m; i++) {
		int x, y, c;

		fin >> x >> y >> c;

		vecini[x].push_back(y);
		vecini[y].push_back(x); // pt muchii de intoarcere
		capacitate[x][y] = c;
	}

	//facem DFS cat timp putem ajunge de la 1 la N

	int flux_total = 0;

	while (true) {
		vizitat.clear();
		vizitat.resize(n + 1, false);
		int trimis = DFS(1, n, INFINIT);

		if (trimis == 0) break; //daca nu am mai putut ajunge de la s la t

		flux_total += trimis;
	}

	fout << flux_total;
	
	return 0;
}