#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
#define nmax 1000
using namespace std;
ifstream f ("maxflow.in");
ofstream g ("maxflow.out");
int d_in[nmax+5], d_out[nmax+5], n, m, start, finish, max_flow;


struct flux
{
    int flux, capacitate;
};

vector< vector < pair<int, flux> > > v(nmax+5);
int parent[nmax+5];
int unde_este_y_in_lista_de_adiacenta_a_lui_x[nmax+5][nmax+5];
int viz[nmax+5];

void bfs2(int start, int finish)
{
    queue<int> q;
    q.push(start);
    viz[start]=true;
    parent[start]=-1;

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

        for(int i=0; i<v[u].size(); i++)
        {
            int y=v[u][i].first;
            if(viz[y]==false && v[u][i].second.capacitate-v[u][i].second.flux>0)
            {
                q.push(y);
                parent[y]=u;
                viz[y]=true;
            }
        }
    }

}

bool bfs(int start, int finish)
{
    bool visited[nmax+5];
    memset(visited, 0, sizeof(visited));

    queue<int> q;
    q.push(start);
    visited[start]=true;
    parent[start]=-1;

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

        for(int i=0; i<v[u].size(); i++)
        {
            int y=v[u][i].first;
            if(visited[y]==false && v[u][i].second.capacitate-v[u][i].second.flux>0)
            {
                q.push(y);
                parent[y]=u;
                visited[y]=true;
            }
        }
    }

    return (visited[finish]==true);
}


int ford_fulkerson(int start, int finish)
{
    int u,q;

    while(bfs(start, finish))
    {
        int path_flow=1e9;
        for(q=finish; q!=start; q=parent[q])
        {
            u=parent[q];
            int valoare_reziduala=v[u][unde_este_y_in_lista_de_adiacenta_a_lui_x[q][u]].second.capacitate-v[u][unde_este_y_in_lista_de_adiacenta_a_lui_x[q][u]].second.flux;
            path_flow=min(path_flow, valoare_reziduala);
        }

        for(q=finish; q!=start; q=parent[q])
        {
            u=parent[q];
            v[u][unde_este_y_in_lista_de_adiacenta_a_lui_x[q][u]].second.flux+=path_flow;
            v[q][unde_este_y_in_lista_de_adiacenta_a_lui_x[u][q]].second.flux-=path_flow;
        }

        max_flow+=path_flow;
    }
    return max_flow;

}

vector<pair<int, int>> muchii;

int main()
{
    int ok=1;
    f>>n;
    f>>m;
    for(int i=0; i<nmax; i++)
    {
        for(int j=0; j<nmax; j++)
        {
            unde_este_y_in_lista_de_adiacenta_a_lui_x[i][j]=-1;
        }
    }
    for(int i=0; i<m; i++)
    {
        int x, y, z, t;
        f>>x>>y>>z;
        d_out[x]+=t;
        d_in[y]+=t;
        flux* flux1=new flux();
        flux1->flux=0;
        flux1->capacitate=z;
        flux* flux2=new flux();
        flux2->flux=z;
        flux2->capacitate=0;
        v[x].push_back(make_pair(y, *flux1));
        unde_este_y_in_lista_de_adiacenta_a_lui_x[y][x]=v[x].size()-1;
        v[y].push_back(make_pair(x, *flux2));
        unde_este_y_in_lista_de_adiacenta_a_lui_x[x][y]=v[y].size()-1;
        delete flux1;
        delete flux2;

        muchii.push_back(make_pair(x,y));
    }
    g<<ford_fulkerson(1, n)<<"\n";

    return 0;
}