#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define min(a,b) ((a) < (b) ? (a) : (b))

#define FIN "maxflow.in"
#define FOUT "maxflow.out"
#define MAXN 1000
#define MAXE 5000
#define oo 0x7FFFFFFF

typedef struct edge
{
        int v,c;
        edge(int _v,int _c) : v(_v), c(_c) {}
} * graph[MAXN];

void readGraph(graph &G,int &N,FILE * fin) {

     int n,m,deg[MAXN];
     struct {int x,y,c;} edg[MAXE];
     
     fscanf(fin,"%d%d",&n,&m);
     
     memset(deg,0,sizeof deg);
     
     for(int i = 0 ; i < m ; ++i) {

             fscanf(fin,"%d%d%d",&edg[i].x,&edg[i].y,&edg[i].c);
             -- edg[i].x; -- edg[i].y;
             deg[ edg[i].x ] ++;
             deg[ edg[i].y ] ++;
     }
     //probabil e busit callocu pe structuri(clase)
     //G = (edge**)calloc(N,sizeof(edge*)); 
     N = n;
     for(int i = 0 ; i < n ; deg[i++] = 0) {
             
                     G[i] = (edge*)calloc(deg[i] + 1,sizeof(edge));
                     G[i][ deg[i] ] = edge(-1,-1);
     }
     for(int i = 0; i < m; ++i)            {
           G[ edg[i].x ] [ deg[ edg[i] . x ] ++ ] = edge(edg[i] . y, edg[i] . c);
           G[ edg[i].y ] [ deg[ edg[i] . y ] ++ ] = edge(edg[i] . x, 0);
     }        
     fclose(fin);
}

void writeSol(int sol,FILE * fout) {
     
    fprintf(fout,"%d",sol);
    fclose(fout);
}


void initFlow(graph G,int ** &R,int N) {

     R = (int**)calloc(N,sizeof(int*));
     
     for(int i = 0 ; i < N; ++i) {
             
             R[i] = (int*)calloc(N,sizeof(int));
             memset(R[i],0,N*sizeof(int));
     }
     
     for(int i = 0; i < N; ++i)
      for(edge *p = G[i]; p -> v != -1 ; ++p)
       R[i][p -> v] += p -> c;
}

bool BFS(graph G,int **R,int N,int * t,int src,int dest) {
    
    int q[MAXN],l = 0, r = -1;
    bool vis[MAXN], f = false;
    memset(vis,false,sizeof vis);
    
    t[src] = -1;
    q[++r] = src;
    vis[src] = true;
    
    for(;l <= r;++l) 
       for(edge *p = G[ q[l] ] ; p->v != -1; ++p)
             if(!vis [ p -> v ] && R[ q[l] ][ p->v ]) {
                     
                     vis[ p -> v] = true;
                     t[ p -> v ] = q[l];
                     q[++r] = p -> v;
                     if(p->v == dest) f = true;
             }
    return f;
}


void writeFlow(int ** R,int N,FILE * flog) {
     
     for(int i=0;i<N;++i) {
      for(int j =0;j< N; ++j)
       fprintf(flog,"%d ",R[i][j] < oo ? R[i][j] : -1);
      fprintf(flog,"\n");
     }
     fprintf(flog,"\n\n\n");
}


int maxFlow(graph G,int N) {
    
   int **R,t[MAXN],flow = 0,src = 0,sink = N - 1;
   
   initFlow(G,R,N);
   
   //FILE * log = fopen("log.txt","w");
   //writeFlow(R,N,log);
   
   for(int minc; BFS(G,R,N,t,src,sink) ;) {
        minc = oo;    
        for(int y = sink; t[y] != -1 ; y = t[y]) 
         minc = min(minc,R[t[y]][y]);
        
        for(int y = sink; t[y] != -1 ; y = t[y]) {
         R[t[y]][y] -= minc;
         R[y][t[y]] += minc;
        }
        flow += minc; //writeFlow(R,N,log);
   }
   return flow;
}

int main() {
    
    graph G;
    int N;
    readGraph(G,N,fopen(FIN,"r"));
    writeSol(maxFlow(G,N),fopen(FOUT,"w"));
    return 0;
}