#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
#include <climits>
#define MAX 1005

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

struct Edge
{
    int to, rev;
    int cap, flow;
};

vector<Edge> graph[MAX];
int level[MAX];
int ptr[MAX];


void addEdge(int u, int v, int cap)
{
    graph[u].push_back({v, graph[v].size(), cap, 0});
    graph[v].push_back({u, graph[u].size() - 1, 0, 0});
}

bool bfs(int source, int sink)
{
    memset(level, -1, sizeof(level));
    level[source] = 0;
    queue<int> q;
    q.push(source);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(auto &edge : graph[u])
        {
            if(level[edge.to] == -1 && edge.flow < edge.cap)
            {
                level[edge.to] = level[u] + 1;
                q.push(edge.to);
                if(edge.to == sink)
                    return true;
            }
        }
    }
    return false;
}

int dfs(int u, int sink, int flow)
{
    if(u == sink)
        return flow;
    for(; ptr[u] < graph[u].size(); ptr[u]++)
    {
        Edge &edge = graph[u][ptr[u]];
        if(level[edge.to] == level[u] + 1 && edge.flow < edge.cap)
        {
            int availableFlow = edge.cap - edge.flow;
            int curr = min(flow, availableFlow);
            int pushed = dfs(edge.to, sink, curr);
            if(pushed > 0)
            {
                edge.flow += pushed;
                graph[edge.to][edge.rev].flow -= pushed;
                return pushed;
            }
        }
    }
}

int dinic(int source, int sink,int n)
{
    int flowMax = 0;
    while(bfs(source, sink))
    {
        memset(ptr, 0, sizeof(ptr));
        int flow;
        while((flow = dfs(source, sink, INT_MAX)) > 0)
            flowMax += flow;
    }
    return flowMax;
}
int main()
{
    int n, m;
    cin>>n>>m;
    for(int i = 0; i < m; i++)
    {
        int u, v, cap;
        cin>>u>>v>>cap;
        addEdge(u, v, cap);
    }
    int source = 1, sink = n;
    int maxFlow = dinic(source, sink, n);
    cout<<maxFlow;
    return 0;
}