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

using namespace std;

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

const int MaxN=1005, Inf=0x3f3f3f3f;
int N,M;
vector<int> G[MaxN];
int C[MaxN][MaxN];

void Read();
bool Drum(vector<int> G[], int N, int C[MaxN][MaxN], int F[MaxN][MaxN], int P[], bool V[]);
int Flux(vector<int> G[], int N, int C[MaxN][MaxN]);

int main()
{
    Read();
    fout<<Flux(G,N,C)<<'\n';

    fout.close();
    return 0;
}

void Read()
{
    fin>>N>>M;
    int x,y,z;
    while(M--)
    {
        fin>>x>>y>>z;
        G[x].push_back(y);
        C[x][y]=z;
        C[y][x]=0;
    }

    fin.close();
}
bool Drum(vector<int> G[], int N, int C[MaxN][MaxN], int F[MaxN][MaxN], int P[], bool V[])
{
    for(int i=2;i<=N;++i)
        V[i]=false;

    queue<int> Q;
    Q.push(1);

    while(!Q.empty())
    {
        int nod=Q.front();
        Q.pop();
        if(nod==N) continue;

        vector<int>::iterator i;
        for(i=G[nod].begin();i!=G[nod].end();++i)
            if(F[nod][*i]<C[nod][*i] && !V[*i])
        {
            P[*i]=nod;
            Q.push(*i);
            V[*i]=true;
        }
    }

    return V[N];
}
int Flux(vector<int> G[], int N, int C[MaxN][MaxN])
{
    int F[MaxN][MaxN],P[MaxN];
    bool V[MaxN];
    V[1]=true;

    for(int i=1;i<=N;++i)
        for(int j=1;j<=N;++j)
        F[i][j]=0;
    P[1]=0;

    int flux_total=0;

    while(Drum(G,N,C,F,P,V))
    {
        vector<int>::iterator i;
        for(i=G[N].begin();i!=G[N].end();++i)
            if(F[*i][N]<C[*i][N] && V[*i])
        {
            P[N]=*i;
            int minim=Inf;
            for(int x=N;x!=1;x=P[x])
                if(C[P[x]][x]-F[P[x]][x]<minim)
                minim=C[P[x]][x]-F[P[x]][x];
            if(!minim) continue;

            flux_total+=minim;

            for(int x=N;x!=1;x=P[x])
            {
                F[P[x]][x]+=minim;
                F[x][P[x]]-=minim;
            }
        }
    }

    return flux_total;
}