/*
    Ideea de rezolvare a algoritmului este urmatoarea:
    Folosim algoritmul de Max Flow. Gata.

Complexitate:
Timp: O()
Memorie: O()
*/
#include <bits/stdc++.h>
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");
class flow
{public:
    int n;
    int m;
    int s;
    int t;
    int viz[1005];
    int parinte[1005];
    int graf[1005][1005];
    int flux_maxim;

    flow(int nn, int mm, int ss, int dd)
    {
        n=nn;
        m=mm;
        s=ss;
        t=dd;
        flux_maxim=0;
    }
    void AddMuchie(int x, int y, int c)
    {
        graf[x][y]=c;
        return;
    }
    bool bfs()
    {
        memset(viz,0,sizeof(viz));
        memset(parinte,0,sizeof(parinte));
        queue <int> q;
        viz[1]=1;
        q.push(1);
        while(!q.empty())
        {
            int act=q.front();
            q.pop();
            if(act==t)
                return true;
            for(int i=1;i<=n;i++)
                if(viz[i]==0 && graf[act][i]!=0)
                {
                    viz[i]=1;
                    parinte[i]=act;
                    q.push(i);
                }
        }
        return false;
    }
    int maxFlow()
    {
        while(bfs())
        {
            for(int i=1;i<n;i++)
            {   if(viz[i]==0 && graf[i][t]!=0)
                {
                    int aux_flux=1<<30;
                    parinte[t]=i;
                    int j=t;
                    while(parinte[j]!=0)
                    {
                        aux_flux=min(aux_flux,graf[parinte[j]][j]);
                        j=parinte[j];
                    }
                    if(aux_flux!=0)
                    {
                        int j=t;
                        while(parinte[j]!=0)
                        {
                            graf[parinte[j]][j]-=aux_flux;
                            graf[j][parinte[j]]+=aux_flux;
                            j=parinte[j];
                        }
                        flux_maxim=flux_maxim+aux_flux;
                    }
                }

            }

        }
        return flux_maxim;
    }
};
int main()
{
    int n,m,x,y,c;
    f>>n>>m;
    flow amogus(n,m,1,n);
    for(int i=1;i<=m;i++)
    {
        f>>x>>y>>c;
        amogus.AddMuchie(x,y,c);
    }
    g<<amogus.maxFlow();
    return 0;
}