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

#define INF 0x3f3f3f3f

using namespace std;

const int kNmax = 1005;

class Task {
 public:
	void solve() {
		read_input();
		print_output(get_result());
	}

 private:
	int n;
	int m;
	vector<int> adj[kNmax];
  	int C[kNmax][kNmax];
  	int F[kNmax][kNmax];
  	bool vis[kNmax];
  	int parent[kNmax];
  	queue<int> q;

	void read_input() {
		ifstream fin("maxflow.in");
		fin >> n >> m;

		memset(C, 0, sizeof C);
		for (int i = 1, x, y, z; i <= m; i++) {
			fin >> x >> y >> z;
			adj[x].push_back(y);
			adj[y].push_back(x);
      		C[x][y] += z;
		}
		fin.close();
	}

	void re_init() {
		for (int i = 1; i <= n; i++) {
			vis[i] = 0;
		}
	}

	int min(int a, int b) {
		return a < b ? a : b;
	}

	bool bfs(int start, int fin) {
		re_init();

		vis[start] = 1;
		q.push(start);

		while (!q.empty()) {
			int cur = q.front();
			q.pop();

			if (cur == fin) {
				continue;
			}

			for (auto next : adj[cur]) {
				if (!vis[next] && F[cur][next] < C[cur][next]) {
					vis[next] = 1;
					parent[next] = cur;
					q.push(next);
				}
			}
		}

		return vis[fin];
	}


	int get_result() {
		/*
		TODO: Calculati fluxul maxim pe graful orientat dat.
		Sursa este nodul 1.
		Destinatia este nodul n.

		In adj este stocat graful neorientat obtinut dupa ce se elimina orientarea
		arcelor, iar in C sunt stocate capacitatile arcelor.
		De exemplu, un arc (x, y) de capacitate z va fi tinut astfel:
		C[x][y] = z, adj[x] contine y, adj[y] contine x.
		*/
		int flow = 0;

		while(bfs(1, n)) {
			for (auto i : adj[n]) {
				if (vis[i]) {
					parent[n] = i;
					int minim = INF;
					int cur = n;

					while (cur != 1 && minim) {
						minim = min(minim, C[parent[cur]][cur] - F[parent[cur]][cur]);
						cur = parent[cur];
					}

					if (minim != 0) {
						flow += minim;
						cur = n;

						while (cur != 1) {
							F[parent[cur]][cur] += minim;
							F[cur][parent[cur]] -= minim;
							cur = parent[cur];
						}
					}
				}
			}
		}

		return flow;
	}

	void print_output(int result) {
		ofstream fout("maxflow.out");
		fout << result << '\n';
		fout.close();
	}
};

int main() {
	Task *task = new Task();
	task->solve();
	delete task;
	return 0;
}