#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using namespace std;

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

const int NMAX = 1'001;

int N, M, C[NMAX][NMAX], Flow[NMAX][NMAX], parent[NMAX];
bool vis[NMAX];
vector < int > G[NMAX];

// C[x][y] - cat e capacitatea muchiei (x, y)
// Flux[x][y] - fluxul muchiei (x, y)
// t - vectorul de tati

bool bfs() {

    for(int i = 1;i <= N;++i) parent[i] = 0, vis[i] = false;

    queue < int > q;

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

    while(!q.empty()) {

        const int node = q.front();
        q.pop();

        for(const int& neighbour : G[node]) {

            if(!vis[neighbour] && C[node][neighbour] > Flow[node][neighbour]) {

                parent[neighbour] = node;
                q.push(neighbour);
                vis[neighbour] = true;

                if(neighbour == N)
                    return true;
            }
        }
    }

    return false;
}

int main() {

    f >> N >> M;

    while(M--) {

        int x, y, capacity;
        f >> x >> y >> capacity;

        // construim graful rezidual
        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y] += capacity;
    }

    int sol{};
    while(bfs()) {

        // parcurg vecinii care au fost vizitati de catre bfs si care contribuie la flux

        for(int node : G[N]) {

            int u = node;
            if(vis[u] && C[u][N] - Flow[u][N] > 0) {

                int minnEdge = C[u][N] - Flow[u][N];

                while(parent[u] != 0) {
                    minnEdge = min(minnEdge, C[ parent[u] ][ u ] -  Flow[ parent[u] ][ u ]);
                    u = parent[u];
                }

                u = node;
                Flow[u][N] += minnEdge;
                Flow[N][u] -= minnEdge;

                while(parent[u] != 0) {
                    Flow[ parent[u] ][u] += minnEdge;
                    Flow[u][parent[u]] -=  minnEdge;
                    u = parent[u];
                }

                sol += minnEdge;
            }
        }
    }

    g << sol;

    return 0;
}