#include <bits/stdc++.h>
using namespace std;

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

vector<vector<int>> gr;
vector<vector<int>> flow;
int father[1002], visited[1002];;

bool bfs(int n, int src, int dest)
{
    for(int i=1; i<=n; i++)
    {
        father[i] = 0;
        visited[i] = 0;
    }

    queue<int> vertexes;
    vertexes.push(src);

    while(!vertexes.empty())
    {
        int currentNode = vertexes.front();
        vertexes.pop();
        for(auto extr2: gr[currentNode])
        {
            if(extr2!=0)
                if(!visited[extr2] and flow[currentNode][extr2]>0) //daca nu am vizitat nodul extr2
                    //si capacitatea muchiei formata din nodul curent si extremitatea 2 permite trecerea flow-ului
                {
                    father[extr2] = currentNode;
                    if(extr2 == dest)
                        return true;
                    vertexes.push(extr2);
                    visited[extr2] = 1;
                }
        }

    }
    return false; //nu am gasit un drum de la sursa la destinatie, inseamna nu mai am drumuri si ca am ajuns la flux maxim
}

int fordFulkerson(int n, int src, int dest)
{
    int u, v, max_flow_for_route, currentNode;

    int srcAux = src, destAux = dest, fNode, finalFlow = 0;

    while(bfs(n, src, dest))
    {
        max_flow_for_route = INT_MAX - 1 ;
        srcAux = src;
        destAux = dest;
        while(destAux!=srcAux)
        {
            //calculez flow-ul maxim de transmis pe drumul gasit de bfs
            max_flow_for_route = min(max_flow_for_route, flow[father[destAux]][destAux]);
            destAux = father[destAux];
        }
        destAux = dest;
        srcAux = src;
        //acum updatez graful rezidual pe drumul gasit de bfs
        while(destAux!=srcAux)
        {
            fNode = father[destAux];
            flow[fNode][destAux] -= max_flow_for_route;    //muchia mea pe directia corecta va avea o capacitate mai mica de flow
            flow[destAux][fNode] += max_flow_for_route;    //muchia pe directia inversa va avea mai mult flow de dat
            //logic pt ca voi avea mai mult flow de extras
            destAux = fNode;
        }

        finalFlow += max_flow_for_route; //adun flow-ul drumului la flow-ul final
    }
    return finalFlow;
}
int main()
{

    int n,m,node1,node2,flux;
    f>>n>>m;
    flow.resize(1002, vector<int>(n+1, 0));
    gr.resize(1002);

    for(int i=1; i<=m; i++)
    {
        f>>node1>>node2>>flux;
        gr[node1].push_back(node2);
        gr[node2].push_back(node1);
        flow[node1][node2] = flux;
    }

    g<<fordFulkerson(n,1,n);
    return 0;
}