// maxflow.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

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

using namespace std;

ifstream fin{ "maxflow.in" };
ofstream fout{ "maxflow.out" };

const int N_MAX = 1000 + 1;
const int M_MAX = 5000 + 1;

int C[N_MAX][N_MAX];
int F[N_MAX][N_MAX];

int N, M;
vector<int> graf[N_MAX];

int sursa, destinatie;
bool vizitat[N_MAX];

int parinte[N_MAX];


void BFS()
{
    for (int i = 1; i <= N; ++i)
    {
        vizitat[i] = false;
        parinte[i] = -1;
    }
        

 
    queue<int> coada;
    coada.push(sursa);

    vizitat[sursa] = true;


    while (coada.empty() == false)
    {
        int u = coada.front();
        coada.pop();

        for (int v : graf[u])
        {
            if (vizitat[v] == true) continue;

            if (F[u][v] == C[u][v]) continue;

        
            vizitat[v] = true;
            parinte[v] = u;
            coada.push(v);

            if (v == destinatie)
            {
                return;
            }
        }
    }
}


int main()
{
    fin >> N >> M;

    sursa = 1;
    destinatie = N;

    for (int i = 1; i <= M; ++i)
    {
        int x, y, c;
        fin >> x >> y >> c;

        C[x][y] = c;

        graf[x].push_back(y);
        graf[y].push_back(x);
    }


    int max_flow{ 0 };

    while (true)
    {
        BFS();

        if (vizitat[destinatie] == false)
        {
            break;
        }


        int min_val = 1e9;

        for (int u = destinatie; u != sursa; u = parinte[u])
        {
            min_val = min(min_val, C[parinte[u]][u] - F[parinte[u]][u]);
        }
           

        for (int u = destinatie; u != sursa; u = parinte[u])
        {
            F[parinte[u]][u] += min_val;
            F[u][parinte[u]] -= min_val;
        }

        max_flow += min_val;
    }


    fout << max_flow;
}