#include <fstream>
#include <vector>
#include <queue>
#include <limits.h>

using namespace std;

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

vector <int> G[1001];
int C[1001][1001],P[1001],F[1001][1001],N;
bool V[1001];

bool Drum(vector<int> G[],int N,int C[1001][1001],int F[1001][1001],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();

    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;
          }
     Q.pop();
    }
  return V[N];
}

int Flux (vector <int> G[],int N,int C[1001][1001])
  {int F[1001][1001],P[1001];
   bool V[1001];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))
           {
             int min1=INT_MAX;
              for(int x=N;x!=1;x=P[x])
                 if(C[P[x]] [x] - F[P[x]] [x]<min1)
                     min1=C[P[x]] [x] - F[P[x]] [x];
             flux_total+=min1;
           for(int x=N;x!=1;x=P[x])
            {
               F[P[x]][x]+=min1;
               F[x][P[x]]-=min1;
           }
         }
     return flux_total;
}

int main()
{
    int m;
    fin>>N>>m;
    for(int i=1;i<=m;++i){
        int x,y,z;
        fin>>x>>y>>z;
        G[x].push_back(y);
        G[y].push_back(x);
        C[x][z]=z;
    }
    fout<<Flux(G,N,C);
    return 0;
}