#include <fstream>
#include <vector>
#include <queue>
using namespace std;
ofstream fout("maxflow.out");
ifstream fin("maxflow.in");
const int NMAX = 1050;
const int INF = 1<<30;

int n, m, flux_maxim;
int Tata[NMAX];
bool Viz[NMAX];
vector<int> Graf[NMAX];

int Cost[NMAX][NMAX], GrafRezidual[NMAX][NMAX];

void citire()
{
    int x, y, z;

    fin >> n >> m;
    for(int i=1; i<=m; i++) {
        fin >> x >> y >> z;
        Cost[x][y] = z;
        Graf[y].push_back(x);
        Graf[x].push_back(y);
    }
}

bool bfs()
{
    queue<int> q;

    fill(Viz + 1, Viz + n + 1, false);
    q.push(1);
    Viz[1] = true;

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

        for(vector<int>::iterator it = Graf[nod].begin(); it != Graf[nod].end(); ++it) {
            if(!Viz[*it] && GrafRezidual[nod][*it] != Cost[nod][*it]) {
                q.push(*it);
                Viz[*it] = true;
                Tata[*it] = nod;
            }
        }
    }

    return Viz[n];
}

int edmondsKarp()
{
    while(1)
    {
        if(!bfs()) break;

        for(vector<int>::iterator it = Graf[n].begin(); it != Graf[n].end(); ++it)
        {
            if(!Viz[*it] || GrafRezidual[*it][n] == Cost[*it][n]) continue;

            Tata[n] = *it;
            int flux = INF;

            for(int v = n; v != 1; v = Tata[v]) {
                int aux = Tata[v];
                flux = min(flux, Cost[aux][v] - GrafRezidual[aux][v]);
            }

            if(!flux) continue;

            for(int v = n; v != 1; v = Tata[v]) {
                int aux = Tata[v];
                GrafRezidual[aux][v] += flux;
                GrafRezidual[v][aux] -= flux;
            }

            flux_maxim += flux;
        }
    }

    return flux_maxim;
}

int main()
{
    citire();
    fout << edmondsKarp() << '\n';
    return 0;
}