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

using namespace std;

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

// Am folosit algoritmul lui Edmonds Karp pentru a optimiza programul, caci foloseste BFS pentru a obtine drumurile de augmentare, astfel le gaseste pe cele mai scurte.
//Cat timp exista drumuri pe care putem sa adaugam flux, augmentam valorile din graful rezidual cu cea mai mica din lant.
//Atunci cand nodul de iesire nu mai este accesibil din nodul de intrare pe graful rezidual oprim cautarea si afisarem rezultatl.
//Complexitate (V * E ^ 2)

int capacity[1005][1005];
///l -> vecorul care retine graful + graful rezidual
vector<int> l[1005];
///n -> noduri, m -> muchii
int n, m;
///vectprul de parinti
int tata[1005] = {0}, viz[1005] = {0};

int bfs()
{
    queue<int> q;
    ///rescriem valorile din vectorul de tati si cel de vizitate
    memset(tata, 0, sizeof(tata));
    memset(viz, 0, sizeof(viz));

    q.push(1);
    viz[1] = 1;

    ///BFS clasic
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        ///iesim cu 1 daca am ajuns la nodul n(cel final)
        if(u == n)
            return 1;
        for(int i = 0; i < l[u].size(); i++)
        {
            int v = l[u][i];
            ///inseamna ca nu e vizitat
            if(capacity[u][v] > 0 && !viz[v])
            {
                ///updatam vectorul de tati pentru a avea drumul
                tata[v] = u;
                ///setam nodul ca vizitat
                viz[v] = 1;
                q.push(v);
            }
        }
    }
    return 0;
}

int edmonds_karp()
{
    ///maxim -> fluxul maxim, minim -> fluxul minim rezidual gasit dupa parcurgerea BFS
    ///u -> nodul curent, v -> vecinul acestuia
    int maxim = 0, minim, u, v;
    ///cat timp prin parcurgerea BFS ajung din nodul 1 in nodul n
    while(bfs())
    {
        ///iterez prin vecinii nodului n(final)
        for(int i = 0; i < l[n].size(); i++)
        {
            u = l[n][i];
            ///daca mai am capacitate disponibila pe muchia dintre noduri
            ///si nodul e vizitat atunci calculam fluxul minim rezidual
            if(capacity[u][n] > 0 && viz[u])
            {
                ///in BFS am pastrat in vectorul de tati drumul gasit pentru transmiterea fluxului
                ///iar acum parcurgem acel drum pentru a gasi minimul si pentru a reactualiza capacitatile
                ///de pe muchii, in functie de cum apar in parcurgere

                minim = capacity[u][n];
                while(tata[u])
                {
                    v = tata[u];
                    minim = min(minim, capacity[v][u]);
                    u = v;
                }
                maxim += minim;
                u = l[n][i];
                capacity[u][n] -= minim;
                capacity[n][u] += minim;
                while(tata[u])
                {
                    v = tata[u];
                    capacity[v][u] -= minim;
                    capacity[u][v] += minim;
                    u = v;
                }
            }
        }
    }
    return maxim;
}

int main()
{
    int s, f, cap, max_flow;
    in>>n>>m;
    while(m)
    {
        in>>s>>f>>cap;
        ///punem capacitatea de la nodul de start la cel de final
        capacity[s][f] = cap;
        ///graful propriu-zis
        l[s].push_back(f);
        ///graful rezidual
        l[f].push_back(s);
        m--;
    }

    ///calculam fluxul maxim cu ajutorul algoritmului Edmonds Karp
    max_flow = edmonds_karp();

    out<<max_flow<<"\n";

    return 0;
}