/*
Algoritm: Edmonds Karp, folosind BFS
- se creaza o matrice cu capacitatile si cu graful rezidual specific grafului dat
- aplicam Edmonds Karp, iar la fiecare pas incercam bfs

----> Complexitatea = O(n*m^2)
*/

#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
#define N 1001
#define INF 1e9

using namespace std;

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

int n, m, a, b, val, i;
int start, stop;
int flow, maxflow;
bool viz[N];
int tata[N];
int capacity[N][N];
vector<int> graph[N];

void Citire()
{
    fin >> n >> m;

    start = 1;
    stop = n;

    tata[start] = -1;

    for(i = 0; i < m; i++)
    {
        fin >> a >> b >> val;
        graph[a].push_back(b);
        graph[b].push_back(a);
        capacity[a][b] = val;
    }
}

bool BFS() 
{
    queue<int> myq;
    memset(viz, false, n * sizeof(bool));

    for (int i = 1; i <= n; i++) 
    {
        myq.push(start);
        viz[start] = true;

        while (!myq.empty()) 
        {
            a = myq.front();
            myq.pop();

            for (int &vecin: graph[a]) {
                if (!viz[vecin] && capacity[a][vecin] != 0) 
                {
                    tata[vecin] = a;
                    if (vecin == stop)
                        return true;

                    viz[vecin] = true;
                    myq.push(vecin);
                }
            }
        }
    }

    return false;
}

void CalcFlowMax() 
{
    while (BFS()) 
    {
        a = stop;
        flow = INF;

        while (a != start) 
        {
            b = tata[a];
            if (capacity[b][a] < flow)
                flow = capacity[b][a];
            a = b;
        }

        a = stop;

        while (a != start)
        {
            b = tata[a];
            capacity[a][b] += flow;
            capacity[b][a] -= flow;
            a = b;
        }

        maxflow += flow;

    }
}

int main()
{
    Citire();
    CalcFlowMax();
    fout << maxflow;
    return 0;
}