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

using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
vector<vector<int>> la, grafRez;
vector<int> tata;
queue<int> q;
vector<bool> viz;

int BFS()
{
    int n = la.size() - 1;
    viz.resize(n + 1, false);
    int maxFlow = 0;
    q.push(1);
    viz[1] = true;

    while (!q.empty()) 
    {
        int nCurent = q.front();
        q.pop();
        for (auto vecin : la[nCurent])
        {
            if (!viz[vecin] && vecin != n && grafRez[nCurent][vecin] > 0)
            {
                viz[vecin] = true;
                q.push(vecin);
                tata[vecin] = nCurent;
            }
        }
    }

    for (auto adiacent : la[n]) 
    {
        if (!viz[adiacent]) 
            continue;

        int F = grafRez[adiacent][n];
        int current = adiacent;

        while (current != 1) 
        {
            F = min(F, grafRez[tata[current]][current]);
            current = tata[current];
        }

        grafRez[adiacent][n] -= F;
        grafRez[n][adiacent] += F;

        current = adiacent;
        while (current != 1) 
        {
            current = tata[current];
            grafRez[tata[current]][current] -= F;
            grafRez[current][tata[current]] += F;
        }
        maxFlow += F;
    }

    return maxFlow;
}

int getMaxFlow()
{
    int n = la.size() - 1;

    tata.resize(n + 1, -1);

    int total_max_flow = 0;
    
    int path_flow = BFS(); //primul augmenting path
    
    while (path_flow) 
    {
        total_max_flow += path_flow;
        path_flow = BFS();
    }

    return total_max_flow;
}

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

    la.resize(n + 1);
    grafRez.resize(n + 1, vector<int>(n + 1, 0));

    for (int i = 0; i < m; i++) 
    {
        int x, y, z;
        fin >> x >> y >> z;
        la[x].push_back(y);
        la[y].push_back(x);
        grafRez[x][y] += z;
    }

    fout << getMaxFlow();

    return 0;
}