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

using namespace std;

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

///flow_sent -> fluxul trimis pe o muchie, capacity -> capacitatea muchiei,
///good_flow -> fluxul maxim trimis pe drumul dat de BFS
int flow_sent[1005][1005], capacity[1005][1005], good_flow[1005] = {0};
///l -> vecorul care retine graful + graful rezidual
vector<int> l[1005];
///n -> noduri, m -> muchii
int n, m;
///vectprul de parinti
int tata[1005] = {-1};

int bfs()
{
    queue<int> q;
    memset(tata, -1, sizeof(tata));
    memset(good_flow, 0, sizeof(good_flow));

    q.push(1);
    tata[1] = -2;
    good_flow[1] = 999;

    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int i = 0; i < l[u].size(); i++)
        {
            int v = l[u][i];
            ///inseamna ca nu e vizitat
            if(tata[v] == -1)
            {
                if(capacity[u][v] - flow_sent[u][v] > 0)
                {
                    ///updatam vectorul de tati
                    tata[v] = u;
                    ///cautam capacitatea reziduala minima
                    good_flow[v] = min(good_flow[u], capacity[u][v] - flow_sent[u][v]);
                    ///verificam daca am ajuns la nodul final
                    if(v == n)
                        return good_flow[v];
                    q.push(v);
                }
            }
        }
    }
    return 0;
}

int edmonds_karp()
{
    int maxim = 0, flow;
    while(true)
    {
        flow = bfs();
        if(flow == 0)
            break;
        maxim += flow;
        int u = n;
        while(u != 1)
        {
            int fiu = tata[u];
            flow_sent[fiu][u] += flow;
            flow_sent[u][fiu] -= flow;
            u = fiu;
        }
    }
    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--;
    }

    max_flow = edmonds_karp();

    out<<max_flow<<"\n";

    return 0;
}