#include <fstream>
#include <vector>
#include <queue>
#include <climits>
#include <cstring>
#define MAXN 2000

using namespace std;
ifstream cin("maxflow.in");
ofstream cout("maxflow.out");

int capacity[MAXN][MAXN];
int residual[MAXN][MAXN];
int parent[MAXN];

bool bfs(int source, int sink, int n)
{
    memset(parent, -1, sizeof(parent));
    queue<int> q;
    q.push(source);
    parent[source] = source;

    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int v = 1; v <= n; v++)
        {
            if(parent[v] == -1 && residual[u][v] > 0)
            {
                parent[v] = u;
                if(v == sink)
                    return true;
                q.push(v);
            }
        }
    }
    return false;
}

int fordFulkerson(int source, int sink, int n)
{
    for(int u = 1; u <= n; u++)
    {
        for(int v = 1; v <= n; v++)
        {
            residual[u][v] = capacity[u][v];
        }
    }
    int maxFlow = 0;

    while(bfs(source, sink, n))
    {
        int pathFlow = INT_MAX;
        for (int v = sink; v != source; v = parent[v])
        {
            int u = parent[v];
            pathFlow = min(pathFlow, residual[u][v]);
        }

        for(int v = sink; v != source; v = parent[v])
        {
            int u = parent[v];
            residual[u][v] -= pathFlow;
            residual[v][u] += pathFlow;
        }
        maxFlow += pathFlow;
    }
    return maxFlow;
}

int main()
{
    int n, m;
    cin >> n >> m;
    memset(capacity, 0, sizeof(capacity));
    for (int i = 0; i < m; i++)
    {
        int u, v, cap;
        cin >> u >> v >> cap;
        capacity[u][v] = cap;
    }

    int source = 1, sink = n;
    int maxFlow = fordFulkerson(source, sink, n);
    cout << maxFlow;

    return 0;
}