/**#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");
/**
int n,m,viz[1001],s,d;
int f[1001][1001],c[1001][1001];
int q[1001];
int bfs()
{
    int p,u,i,x;
    q[0]=s;
    p=u=0;
    viz[s]=1;
    while(p<=u&&!viz[d])
    {
        x=q[p++];
        for(int i=1;i<=n;i++)
        if(!viz[i])
            if(f[x][i]<c[x][i]) {viz[i]=x; q[++u]=i;}
            else
            if(f[i][x]>0) {viz[i]=-x; q[++u]=i;}
    }
    return !viz[d];
}
void damfluxlapompa()
{
    int i,a,b,lg,v;
    int l[101];

    do
    {
        memset(viz,0,sizeof(viz));
        if(bfs()) return ;
        l[0]=d;lg=0;
        a=b=INF;
        while(l[lg]!=s)
        {
            ++lg;
            l[lg]=abs(viz[l[lg-1]]);
            if(viz[l[lg-1]]>0) a=min(a,c[l[lg]][l[lg-1]]-f[l[lg]][l[lg-1]]);
            else
            if(viz[l[lg-1]]<0) b=min(b,f[l[lg-1]][l[lg]]);
        }
        v=min(a,b);
        for(int i=lg;i>0;i--)
        if(viz[l[i-1]]>0)
            f[l[i]][l[i-1]]+=v;
        else
            f[l[i-1]][l[i]]-=v;
    }while(1);
}
int main()
{
    f1>>n>>m;
    s=1; d=n;
    for(int i=1;i<=m;i++)
    {
        int x,y,flux;
        f1>>x>>y>>flux;
        c[x][y]=flux;
    }
    damfluxlapompa();
    int sum=0;
    for(int i=1;i<=n;i++)
        sum+=f[i][d];
    g<<sum<<'\n';
    return 0;
}
**/

#include<fstream>
#include<cstring>
using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
int C[1001][1001];//matricea costurilor
int n,m;
int T[1001];//vector TATA din BFS

int BFS() //returneaza 1 daca gaseste drum de crestere de la 1 la n
{
    int s=1,d=1,j,i,X[1001];
    memset(T,0,sizeof(T));
    memset(X,0,sizeof(X));
    X[1] = 1;T[1]=-1;
    while(s<=d)
    {   i=X[s];
        for(j=1;j<=n;j++){
            if(T[j]==0 && C[i][j]>0)
            {
                X[++d]=j;
                T[j]=i;
                if(j==n) return 1;
            }
        }
        s++;
    }
    return 0;
}
int flux_maxim()
{
    int i,minn,j,flux=0;
    while(BFS())//cat timp mai gaseste drumuri de crestere
      {
                minn=999999;
                j=n;
                while(j!=1)//calculeaza valoarea minima a drumului
                {
                    if(C[T[j]][j]<minn)
                        minn=C[T[j]][j];
                    j=T[j];
                }
                j=n;
                while(j!=1)//scade capacitatile pe drumul de crestere
                    {   C[T[j]][j]-=minn;
                        C[j][T[j]]+=minn;
                        j=T[j];
                    }
                 flux+=minn;//aduna minimul la fluxul maxim
      }
    return flux;
}

int main()
{
    int i,x,y,c;
    fin>>n>>m;
    for(i=0;i<=m;++i)
    {
        fin>>x>>y>>c;
        C[x][y]=c;
    }
    fout<<flux_maxim();
    return 0;
}