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

using namespace std;

int n, m, maxFlow;
vector<vector<int>> adjList;
vector<vector<int>> capacityMap;
vector<int> parentMap;

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

void ReadInputs() {
    myIn >> n >> m;

    adjList.resize(n);
    capacityMap.resize(n, vector<int>(n));
    parentMap.resize(n, -1);
    parentMap[0] = INT_MAX;
    for (int i = 0; i < m; i++) {
        int x, y, f;
        myIn >> x >> y >> f; x--; y--;
        adjList[x].push_back(y);
        adjList[y].push_back(x);
        capacityMap[x][y] = f;
    }
}

bool BFS() {
    fill(parentMap.begin(), parentMap.end(), -1);
    queue<int> q;
    q.push(0);

    while (q.empty() == false) {
        int currentNode = q.front();
        q.pop();

        if (currentNode == (n - 1)) {
            return true;
        }

        for (int j = 0; j < adjList[currentNode].size(); j++) {
            int nextNode = adjList[currentNode][j];
            int capacity = capacityMap[currentNode][nextNode];

            if ((parentMap[nextNode] == -1) && (capacity > 0)) {
                q.push(nextNode);
                parentMap[nextNode] = currentNode;
            }
        }
    }

    return false;
}

void EdmondsKarp() {
    while (BFS() == true) {
        int minFlow = INT_MAX;
        for (int node = n - 1; node != 0; node = parentMap[node]) {
            int prevNode = parentMap[node];
            minFlow = min(minFlow, capacityMap[prevNode][node]);
        }

        for (int node = n - 1; node != 0; node = parentMap[node]) {
            int prevNode = parentMap[node];
            capacityMap[node][prevNode] += minFlow;
            capacityMap[prevNode][node] -= minFlow;
        }
        
        maxFlow += minFlow;
    }
}

void Output() {
    myOut << maxFlow;
    myOut.close();
    myIn.close();
}

int main() {
    ReadInputs();
    EdmondsKarp();
    Output();
}