#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define DIM 1005
FILE *f=fopen("maxflow.in","r"), *g=fopen("maxflow.out","w");

using namespace std;

vector <int> v[DIM];

int N, M, F[DIM][DIM], C[DIM][DIM], T[DIM], FLUXtotal = 0, Q[DIM];
bool viz[DIM];

void Citire(){
int i, x, y, c;

    fscanf(f,"%d %d\n",&N,&M);

    for(i=1;i<=M;i++){

        fscanf(f,"%d %d %d\n",&x,&y,&c);

        v[x].push_back(y);
        v[y].push_back(x);

        C[x][y] = c;

    }

}

int BFS(){
int p, u, i, nod, NEWnod;

    memset(viz,0,sizeof(viz));

    p = u = 1;
    Q[1] = 1;
    viz[1] = 1;

    while( p <= u ){

        nod = Q[p];

        for(i=0;i<v[nod].size();i++){

            NEWnod = v[nod][i];

            if( viz[NEWnod] == 0 && C[nod][NEWnod] - F[nod][NEWnod] > 0 ){

                viz[NEWnod] = 1;
                T[NEWnod] = nod;
                Q[++u] = NEWnod;

            }

        }

        p ++;

    }

    return viz[N];
}

void Rezolvare(){
int i, nod, minim, U;

    while( BFS() )

        for(i=0;i<v[N].size();i++){

            nod = v[N][i];

            if( viz[nod] == 1 && C[nod][N] - F[nod][N] != 0 ){  // daca pun > 0 sau deloc

                minim =  C[nod][N] - F[nod][N];

                U = nod;
                while( U != 1 ){
                    minim = min( C[ T[U] ][ U ] - F[ T[U] ][ U ], minim );
                    U = T[U];
                }

                FLUXtotal += minim;

                F[ nod ][ N ] += minim;
                F[ N ][ nod ] -= minim;

                U = nod;
                while( U != 1 ){

                    F[ T[U] ][ U ] += minim;
                    F[ U ][ T[U] ] -= minim;

                    U = T[U];

                }

            }

        }

    fprintf(g,"%d\n",FLUXtotal);

}

int main(){

    Citire();
    Rezolvare();

return 0;
}