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

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

int gr[1001][1001], resGr[1001][1001];

bool bfs(int n, int src, int dest, int father[])
{
    bool visited[n+1];
    memset(visited, 0, sizeof(visited));
    memset(father, 0, sizeof(father));
    queue<int> vertexes;
    vertexes.push(src);

    while(!vertexes.empty())
    {
        int currentNode = vertexes.front();
        vertexes.pop();
        for(int i=1;i<=n;i++)
        {
            if(!visited[i] and resGr[currentNode][i] >0) //daca nu am vizitat nodul i, si in graful rezidual mai am flux de dat
            {
                father[i] = currentNode;
                if(i == dest)
                    return true;        //am gasit un drum de la sursa la destinatie, merg si updatez graful rezidual
                vertexes.push(i);
                visited[i] = true;
            }
        }
    }
    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;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
            resGr[i][j] = gr[i][j];
    int father[n+1];
    memset(father, 0, sizeof(father));
    int srcAux = src, destAux = dest, fNode, finalFlow = 0;

    while(bfs(n, src, dest, father))
    {
        max_flow_for_route = INT_MAX;
        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, resGr[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];
            resGr[fNode][destAux] -= max_flow_for_route;    //muchia mea pe directia corecta va avea o capacitate mai mica de flow
            resGr[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,flow;
    f>>n>>m;
    for(int i=1;i<=m;i++)
    {
        f>>node1>>node2>>flow;
        gr[node1][node2] = flow;
    }
    g<<fordFulkerson(n,1,n);

}