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

FILE *fin, *fout;

class Graph{
    private:
        std::vector <std::vector <int>> edge;
        std::vector <std::vector<int>> cap;
        std::vector <int> parent;
        std::vector <bool> visited;
        int V, source, sink;

        bool bfs(){
            std::fill(visited.begin(), visited.end(), false);
            visited[source] = true;
            std::queue <int> q;
            q.push(source);

            while(q.empty() == false){
                int node = q.front();
                q.pop();
                if(node == sink) continue;

                for(int next: edge[node]){
                    if(visited[next] == false and cap[node][next] > 0){
                        parent[next] = node;
                        visited[next] = true;
                        q.push(next);
                    }
                }
            }

            return visited[sink];
        }

    public:
        Graph(int size){
            V = size;
            edge.resize(V+1);
            cap.resize(V+1);
            for(auto &line: cap)
                line.resize(V+1);
            visited.resize(V+1);
            parent.resize(V+1);
        }

        void addEdge(int src, int dest, int capacity){
            edge[src].push_back(dest);
            edge[dest].push_back(src);
            cap[src][dest] = capacity;
        }

        int maxFlow(int src, int dest){
            source = src;
            sink = dest;
            int maxFlow = 0, flow;

            while(bfs() == true){
                for(int it: edge[sink]){
                    if(visited[it] == true and cap[it][sink] > 0){
                        flow = 1e9;
                        parent[sink] = it;
                        for(int node = sink; node != source; node = parent[node])
                            flow = std::min(flow, cap[parent[node]][node]);
                        for(int node = sink; node != source; node = parent[node]){
                            cap[parent[node]][node] -= flow;
                            cap[node][parent[node]] += flow;
                        }
                        maxFlow += flow;
                    }
                }
                
            }

            return maxFlow;
        }

};

int main(){
    fin = fopen("maxflow.in", "r");
    fout = fopen("maxflow.out", "w");

    int V, E;
    fscanf(fin, "%d %d", &V, &E);
    Graph graph(V);

    for(int i=0, src, dest, cap; i<E; i++){
        fscanf(fin,  "%d %d %d", &src, &dest, &cap);
        graph.addEdge(src, dest, cap);
    }

    fprintf(fout, "%d", graph.maxFlow(1, V));

    fclose(fin);
    fclose(fout);
    return 0;
}