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

using namespace std ;

const int NMAX =    1005 ;
const int INF = 0x3f3f3f3f ;

ifstream fin("maxflow.in") ;
ofstream fout("maxflow.out") ;

int N, M, FLOW[NMAX][NMAX], T[NMAX];
int flow_min, maxflow ;
bitset <NMAX> use ;
vector <int> V[NMAX] ;
queue <int> Q, Q2 ;

inline bool BFS()
{
    Q.push(1) ;
    use[1] = 1 ;

    while(!Q.empty())
    {
        int nod = Q.front() ;
        Q.pop();

        if(nod == N)
        {
            Q = queue<int>() ;
            return true;
        }

        for(vector <int> ::iterator it = V[nod].begin() ; it != V[nod].end() ; ++ it)
            if(!use[*it] && FLOW[nod][*it] > 0)
            {
                use[*it] = 1 ;

                T[*it] = nod ;

                if(*it == N)
                    Q2.push(nod) ;

                Q.push(*it) ;
            }

            else if(*it == N && FLOW[nod][*it] > 0)
                Q2.push(nod) ;
    }


    return false ;
}

inline void edmond_karp()
{

    while(BFS())
    {

        while(!Q2.empty())
        {
            flow_min = INF ;
            int nod = Q2.front() ;
            Q2.pop() ;
            int aux_nod = nod ;

            while(aux_nod != 1)
            {
                flow_min = min(flow_min, FLOW[T[aux_nod]][nod]) ;
                aux_nod = T[aux_nod] ;
            }


            maxflow += flow_min ;
            FLOW[nod][N] -= flow_min ;
            FLOW[N][nod] += flow_min ;
            aux_nod = nod ;

            while(aux_nod != 1)
            {
                FLOW[aux_nod][T[aux_nod]] += flow_min;
                FLOW[T[aux_nod]][aux_nod] -= flow_min ;
                aux_nod = T[aux_nod] ;
            }
        }

        use.reset() ;
    }

}


int main()
{
    fin >> N >>  M ;

    for(int i = 1 ; i <= M ; ++ i)
    {
        int x, y, z ;
        fin >> x >> y >> z ;
        V[x].push_back(y) ;
        V[y].push_back(x) ;
        FLOW[x][y] += z ;
    }

    edmond_karp();

    fout << maxflow << '\n' ;

    fin.close() ;
    fout.close() ;
    return 0 ;
}