#include <fstream>
#include <vector>
#include <queue>
#define NM 1005
#define inf 1000000000

using namespace std;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

vector < int > G[NM];
queue < int > q;

int n, m, flux;
int c[NM][NM], f[NM][NM];
int T[NM];

bool bfs()
{
    int ok=0, p, i;
    T[1]=-1;
    for (i=1; i<=n; i++)
        T[i]=0;
    q.push(1);
    while (!q.empty())
    {
        p=q.front();
        int sz=G[p].size();
        for (i=0; i<sz; i++)
        {
            if (T[G[p][i]]==0 && c[p][G[p][i]]>f[p][G[p][i]])
            {
                if (G[p][i]==n)
                {
                    ok=1;
                }
                else
                {
                    T[G[p][i]]=p;
                    q.push(G[p][i]);
                }
            }
        }
        q.pop();
    }
    return ok;
}

void dinic()
{
    int minim, i, j;
    while (bfs())
    {
        int sz=G[n].size();
        for (j=0; j<sz; j++)
        {
            if (T[G[n][j]]!=0 && c[G[n][j]][n]>f[G[n][j]][n])
            {
                T[n]=G[n][j];
                int minim=inf;
                for (i=n; i!=1; i=T[i])
                {
                    if (minim>c[T[i]][i]-f[T[i]][i])
                    {
                        minim=c[T[i]][i]-f[T[i]][i];
                    }
                }
                if (minim<=0) continue;
                flux+=minim;
                for (i=n; i!=1; i=T[i])
                {
                    f[T[i]][i]+=minim;
                    f[i][T[i]]-=minim;
                }
            }
        }
    }
}

int main()
{
    int i, x, y, cost;
    fin>>n>>m;
    for (i=1; i<=m; i++)
    {
        fin>>x>>y>>cost;


        c[x][y]=cost;
        G[x].push_back(y);
        G[y].push_back(x);
    }

    dinic();

    fout<<flux;
    return 0;
}