#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

#define MAX 1024
#define INF 1000000000

int capacity[MAX][MAX];
int residualCapacity[MAX][MAX];
int parent[MAX];

vector<int> listaAdiacenta[MAX];

int numarNoduri;
int numarMuchii;

int noduriVizitate[MAX];

ifstream in("maxflow.in");

void ConstruireListaAdiacenta(int nod1, int nod2)
{
    listaAdiacenta[nod1].push_back(nod2);
    listaAdiacenta[nod2].push_back(nod1);
}

void ConstruireMatriceCapacitate()
{
    int nod1;
    int nod2;
    int capacitate;

    for (int i = 1; i <= numarMuchii; ++i)
    {
        in>> nod1>> nod2 >> capacitate;

        capacity[nod1][nod2] += capacitate;
        ConstruireListaAdiacenta(nod1, nod2);
    }
}

int BFS()
{
    int nod;
    queue<int> tail;
    tail.push(1);

    fill(noduriVizitate, noduriVizitate + numarNoduri + 1, 0);
    noduriVizitate[1] = 1;

    while( !tail.empty() )
    {
        nod = tail.front();
        tail.pop();

        if( nod == numarNoduri )
        {
            continue;
        }

        for ( auto &it : listaAdiacenta[nod] )
        {
            if (capacity[nod][it] == residualCapacity[nod][it] || noduriVizitate[it] )
            {
                continue;
            }

            noduriVizitate[it] = 1;
            tail.push(it);
            parent[it] = nod;

            if (it == numarNoduri)
            {
                return 1;
            }
        }
    }

    return noduriVizitate[numarNoduri];
}

int MaxFlow()
{
    int flowMax;
    int flowMin;
    int nod;

    for (flowMax = 0; BFS(); )
    {
        for( auto &it : listaAdiacenta[numarNoduri] )
        {
            if( residualCapacity[it][numarNoduri] == capacity[it][numarNoduri] || !noduriVizitate[it] )
            {
                continue;
            }
            parent[numarNoduri] = it;

            flowMin = INF;
            for (nod = numarNoduri; nod != 1; nod = parent[nod])
            {
                flowMin = min(flowMin, capacity[ parent[nod] ][nod] - residualCapacity[ parent[nod] ][nod]);
            }

            if( flowMin == 0 )
            {
                continue;
            }

            for (nod = numarNoduri; nod != 1; nod = parent[nod])
            {
                residualCapacity[ parent[nod] ][nod] += flowMin;
                residualCapacity[nod][ parent[nod] ] -= flowMin;
            }

            flowMax += flowMin;
        }
    }

    return flowMax;
}

int main()
{
    in>> numarNoduri>> numarMuchii;

    ConstruireMatriceCapacitate();

    ofstream out("maxflow.out");
    out<< MaxFlow();

    in.close();
    out.close();
    return 0;
}