#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <climits>
#include <cstring>
using namespace std;

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

int src, dst, n, m;
int tati[1000], visited[1001], rGraph[1001][1001];
vector<vector<int>> adjList;

// folosim algoritmul BFS pt EK
// verifica daca exista cale din sursa in destinatie
// stocheaza in tati[] drumul din sursa in destinatie
bool bfs()
{
    memset(visited, 0, sizeof(visited));    // nodurile initial nu sunt vizitate
    
    // facem o coada, punem elementul sursa si marcam sursa ca fiind vizitata
    queue<int> q;
    q.push(src);
    visited[src] = 1;

    // Loop standart BFS
    while(!q.empty())
    {
        int aux = q.front();
        q.pop();

        for(auto nodCurent : adjList[aux])
        {
            if(visited[nodCurent] == 0 && rGraph[aux][nodCurent] > 0)
            {
                // daca am gasit conexiune cu nodul destinatie
                // nu mai are rost sa facem BFS
                // setam parintele si returnam true
                tati[nodCurent] = aux;
                if(nodCurent == dst)
                    return 1;

                q.push(nodCurent);
                visited[nodCurent] = 1;
            }
        }

    }
    // in acest caz nu se poate intoarce la destinatie
    return 0;
}

int fordF()
{
    int max_flow = 0;
    while(bfs())
    {
        for(auto nod : adjList[dst])
        {
            
            int path_flow = INT_MAX;
            int aux = dst;

            // gasim capacitatea minima residuala muchiilor a caii pe care am gasit-o cu BFS
            // alternativ, gasim flow maxim a caii gasite
            while(aux!=src)
            {
                path_flow = min(path_flow, rGraph[tati[aux]][aux]);
                aux = tati[aux];
            }

            aux = dst;

            // updatam capacitatea residuala a nodurilor
            while(aux!=1)
            {
                rGraph[tati[aux]][aux] -= path_flow;
                rGraph[aux][tati[aux]] += path_flow;
                aux = tati[aux];
            }

            max_flow += path_flow;
        }
    }
    return max_flow;
}

int main()
{
    src = 1;
    fcin >> n >> m;
    dst = n;

    adjList.resize(n+1);

    // construim graful
    int x, y, cost;
    for(int i = 0; i<m; i++)
    {
        fcin>>x>>y>>cost;
        adjList[x].push_back(y);
        adjList[y].push_back(x);

        rGraph[x][y] = cost;
    }
    fcout<<fordF();
    return 0;
}