#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;
}