#include <iostream>
#include <fstream>
#include <queue>
#include <algorithm>
#include <limits>
using namespace std;

#define N_MAX 1010
#define UNDEFINED -1

int capacityMatrix[N_MAX][N_MAX] = {UNDEFINED}; // intializeaza matricea
int n;
vector<int> path;

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

/**
* se ruleaza bfs pana se intalneste parintele destinatiei,
* se goleste vectorul care retine drumul, iar daca parintele destinatiei este nedefinit,
* atunci inseamna ca nu mai exista drum de ameliorare, altfel se reface drumul pornind de la dest.
*/
int bfs(int source, int destination) {
    queue<int> q;
    int parent[N_MAX];

    for (int i = 1; i <= n; i++) {
        parent[i] = UNDEFINED;
    }

    q.push(source);

    while (parent[destination] == UNDEFINED && !q.empty()) {
        int current = q.front();
        q.pop();

        for (int i = 1; i <= n; i++) {
            if (capacityMatrix[current][i] > 0 && parent[i] == UNDEFINED) {
                parent[i] = current;
                q.push(i);
            }
        }
    }

    path.clear();

    /* nu mai exista nici o cale */
    if (parent[destination] == UNDEFINED)
        return 0;

    /* reface drumul */
    int node = destination;
    while (node != source) {
        path.push_back(node);
        node = parent[node];
    }
    /* adauga si sursa */
    path.push_back(source);

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

    return 1;
}

int maxFlow(int source, int destination) {
    int minFlow, flow = 0;

    while (bfs(source, destination)) {
        /* minimul capacitatiilor din drumul ales */
        minFlow = numeric_limits<int>::max();
        for (unsigned int i = 0; i < path.size() - 1; i++) {
            int u = path.at(i);
            int v = path.at(i + 1);

            minFlow = min(minFlow, capacityMatrix[u][v]);
        }
        /* actualizarea capacitatiilor pe muchii si pe inversele lor */
        for (unsigned int i = 0; i < path.size() - 1; i++) {
            int u = path.at(i);
            int v = path.at(i + 1);

            capacityMatrix[u][v] -= minFlow;
            capacityMatrix[v][u] += minFlow;
        }
        flow += minFlow;
    }

    return flow;
}

int main() {
    int n1, n2, c, m;

    in >> n >> m;

    for (int i = 0; i < m; i++) {
        in >> n1 >> n2 >> c;
        capacityMatrix[n1][n2] = c;
        capacityMatrix[n2][n1] = 0;
    }

    in.close();

    out << maxFlow(1, n);

    out.close();

    return 0;
}