#include <fstream>
#include <vector>
#include <queue>
#define DIM 1010

using namespace std;

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

vector <int> L[DIM];
int C[DIM][DIM];
int F[DIM][DIM];
int T[DIM];
int U[DIM];
queue <int> Q;

int N,M,i,j,minim,flux,x,y,z;

int bfs(int nod){
    int gasit = 0;

    for(int i=1;i<=N;i++)
        U[i] = 0;

    U[1] = 1;

    Q.push(1);
    while(!Q.empty()){
        int node = Q.front();
        Q.pop();
        for(std::vector <int>::iterator it=L[node].begin();it!=L[node].end();it++){
            if(U[*it] == 0 && C[node][*it] > F[node][*it]){
                Q.push(*it);
                U[*it]=1;
                T[*it]=node;
                if(*it == N)
                    gasit=1;
            }
        }
    }
    return gasit;
}

int main(){

    fin >> N >> M;
    for(int i=1;i<=M;i++){
        fin >> x >> y >> z;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y] = z;
    }

    while(bfs(1)){
        for(std::vector <int>::iterator it=L[N].begin();it!=L[N].end();it++){
            int p = *it;
            if(C[p][N] > F[p][N] && U[p] == 1){
                minim = C[p][N] - F[p][N];
                int u = p;
                while(T[u] != 0){
                    if(C[T[u]][u] - F[T[u]][u] < minim){
                        minim = C[T[u]][u] - F[T[u]][u];
                    }
                    u = T[u];
                }
                flux += minim;

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

                u = p;
                while(T[u]!=0){
                    F[T[u]][u] += minim;
                    F[u][T[u]] -= minim;
                    u = T[u];
                }
            }
        }
    }

    fout << flux << "\n";

}