#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
#include <fstream>

using namespace std;

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

const int INF = 1e9;
const int N_MAX = 505;

int C[N_MAX][N_MAX]; 
int F[N_MAX][N_MAX]; 
vector<int> adj[N_MAX];
int n, s, t;


int bfs(int P[]){
    static int M[N_MAX];
    queue<int> q;

    for(int i  = 1; i <= n; i++){
            P[i]= -1;
            M[i] = 0;
    }

    P[s] = -2;
    M[s] = INF;

    q.push(s);
    while(!q.empty()){
        int u = q.front();
        q.pop();

        for (int v : adj[u]) {
            if (P[v] == -1 && C[u][v] - F[u][v] > 0) {
                P[v] = u;
                M[v] = min(M[u], C[u][v] - F[u][v]);

                if (v == t) return M[t];
                q.push(v);
                
            }
        }
    }
    return 0;
}

int EK(){
    int maxf = 0;
    static int P[N_MAX];

    while(true){
        int m = bfs(P);
        if(m == 0) break;

        maxf += m;
        int v = t;
        while(v != s){
            int u = P[v];
            F[u][v] += m;
            F[v][u] -= m;
            v = u;
        }


    }
    return maxf;

}

int main(){
    int m;
    fin >> n >> m;
    memset(C, 0, sizeof(C));
    memset(F, 0, sizeof(F));
    for (int i = 1; i <= n; i++) adj[i].clear();
    for(int i = 0; i < m; i++){
        int u, v, c;
        fin >> u >> v >> c;
        C[u][v] += c;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    s = 1;
    t = n;
    fout  << EK();
    
    fin.close();
    fout.close();
}