/*
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>
#define N 1001
#define INF 1e9

using namespace std;

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

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

void Citire()
{
    int i;
    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> myqueue;
    memset(viz, false, n * sizeof(bool));

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

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

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

                    viz[vecin] = true;
                    myqueue.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;
}




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

using namespace std;

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

int n, m, a, b, c, maxfl, fl, start = 1, sink, i;
vector<int> graph[1001];
int tata[1001];
int capacitate[1001][1001];
bool viz[1001];

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

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


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

            for (int &vecin: graph[a]) {
                if (!viz[vecin] && capacitate[a][vecin] != 0) {
                    tata[vecin] = a;

                    if (vecin == sink)
                        return true;

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

    return false;
}

void maxflow() {
    while (bfs()) {
        a = sink;
        fl = INT_MAX;

        while (a != start) {
            b = tata[a];
            if (capacitate[b][a] < fl)
                fl = capacitate[b][a];

            a = b;
        }

        a = sink;

        while (a != start) {
            b = tata[a];
            capacitate[a][b] += fl;
            capacitate[b][a] -= fl;

            a = b;
        }

        maxfl += fl;

    }
}

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

    sink = n;
//    viz = (bool *) realloc(viz, n * sizeof(bool));
    tata[start] = -1;


//    graph.resize(n + 1);
//    tata.resize(n + 1);

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

//    fin.close();

    maxflow();

    fout << maxfl;
//    fout.close();

    return 0;
}

*/