#include <bits/stdc++.h>

using namespace std;

class Graph{
    int source, dest, n;
    vector < vector <int> > capacity;
    vector < vector <int> > adj;
    vector < int > parent;
    vector < bool > vis;

    bool bfs() {
        fill(vis.begin(), vis.end(), false);

        int node = source;
        vis[node] = true;
        queue <int> q;
        q.push(node);

        while (!q.empty()) {
            node = q.front();
            q.pop();

            for (auto& it : adj[node])
                if (!vis[it] and capacity[node][it]) {
                    vis[it] = true;
                    parent[it] = node;
                    q.push(it);
                }
        }

        return vis[dest];
    }

public:
    Graph(int _n, int _source, int _dest) : n(_n), source(_source), dest(_dest) {
        adj.resize(n + 1);
        capacity.resize(n + 1);
        for (auto& line : capacity)
            line.resize(n + 1);
        parent.resize(n + 1);
        vis.resize(n + 1);
    }

    void add_edge(int node1, int node2, int cap = 1) {
        adj[node1].push_back(node2);
        adj[node2].push_back(node1);
        capacity[node1][node2] = cap;
    }

    int max_flow() {
        int maxflow = 0;

        while (bfs()) {
            for (auto& it : adj[dest]) 
                if (vis[it] and capacity[it][dest]) {
                    parent[dest] = it;
                    int flow = INT_MAX;

                    for (int node = dest; node != source; node = parent[node])
                        flow = min(flow, capacity[parent[node]][node]);

                    for (int node = dest; node != source; node = parent[node]) {
                        capacity[parent[node]][node] -= flow;
                        capacity[node][parent[node]] += flow;
                    }

                    maxflow += flow;
                }
        }

        return maxflow;
    }
};

int main() {
    ifstream cin("maxflow.in");
    ofstream cout("maxflow.out");

    int n, m;
    cin >> n >> m;
    Graph G(n, 1, n);

    while (m--) {
        int x, y, z;
        cin >> x >> y >> z;
        G.add_edge(x, y, z);
    }

    cout << G.max_flow();

    return 0;
}