#include<bits/stdc++.h>

using namespace std;

int const NMax = 1005;
vector <int> G[NMax];
vector <int>::iterator p[NMax];
list <int> L;
int F[NMax][NMax], Lv[NMax], over[NMax];
int n, m;

void Read()
{
    int x, y, c;
    scanf("%d %d", &n, &m);
    for(int i = 0; i < m; i++){
        scanf("%d %d %d", &x, &y, &c);
        if(!F[x][y]){
            G[x].push_back(y);
            G[y].push_back(x);
        }
        F[x][y] += c;
    }
}

void discharge(int node)
{
    while(over[node] > 0){

        if(p[node] == G[node].end()){
            Lv[node]++;
            p[node] = G[node].begin();
        }

        else{
            if((Lv[node] == Lv[*p[node]] + 1) and F[node][*p[node]]){
                int val = min(over[node], F[node][*p[node]]);
                over[node] -= val;
                over[*p[node]] += val;
                F[node][*p[node]] -= val;
                F[*p[node]][node] += val;
            }
            else
                p[node]++;
        }
    }
}

void Solve()
{
    int i, v, old;

    Lv[1] = n;
    for(auto i : G[1]){
        F[i][1] = F[1][i];
        F[1][i] = 0;
        over[i] += F[i][1];
    }
    for(i = 2; i < n; i++){
        L.push_back(i);
        p[i] = G[i].begin();
    }

    list <int>::iterator node = L.begin();
    while(node != L.end()){
        old = Lv[*node];
        discharge(*node);
        if(old < Lv[*node]){
            v = *node;
            L.erase(node);
            L.push_front(v);
            node = L.begin();
        }
        node++;
    }
    printf("%d\n", over[n]);
}

void CleanUp()
{
    int i;
    memset(over, 0, sizeof(over));
    memset(Lv, 0, sizeof(Lv));
    for(i = 0; i <= n; i++){
        G[i].clear();
        memset(F[i], 0, sizeof(F[i]));
    }
    L.clear();
}

int main()
{
    freopen("maxflow.in", "r", stdin);
    freopen("maxflow.out", "w", stdout);
    Read();
    Solve();
    return 0;
}