#include<stdio.h>

#include<string.h>

#include<queue>

#include<algorithm>

using namespace std;

const int INF = 0xfffffff;

const int MAXN =  + ;

//邻接矩阵存放图。

int flow[MAXN][MAXN];

//mark[]标记是否访问过，pre[]记录增广路。

int mark[MAXN], pre[MAXN];

int m, n, f; //f为最大流。

void max_flow()

{

    //不断寻找增广路，知道找不到为止，找不到的标志为 mark[n]==0.

    while() {

        memset(mark, , sizeof(mark));

        memset(pre, , sizeof(pre));

        queue<int> Q;

        mark[] = ;

        Q.push();

        while( !Q.empty() ) {

            int cnt = Q.front();

            Q.pop();

            //找到增广路，跳出。

            if(cnt == n) {

                break;

            }

            for(int i = ; i <= n; i++) {

                if(!mark[i] && flow[cnt][i] > ) {

                    mark[i] = ;

                    Q.push(i);

                    pre[i] = cnt;

                }

            }

        }

        //如果没找到可增广的路，直接跳出.

        if( !mark[n] ) {

            break;

        }

        //计算该增广路最大可增加的流量.

        int minx = INF;

        for(int i = n; i != ; i = pre[i]) {

            minx = min( flow[pre[i]][i], minx );

        }

        for(int i = n; i != ; i = pre[i]) {

            flow[pre[i]][i] -= minx; //更新正向流量。

            flow[i][pre[i]] += minx; //更新反向流量。

        }

        f += minx;

    }

}

int main()

{

    while(scanf("%d %d", &m, &n) != EOF) {

        memset(flow, , sizeof(flow));

        for(int i = ; i < m; i++) {

            int u, v, len;

            scanf("%d %d %d", &u, &v, &len);

            //这个题有重边的情况，所以要flow[u][v] += len;直接等于过不去。

            flow[u][v] += len;

        }

        f = ;

        max_flow();

        printf("%d\n", f);

    }

    return ;

}

    #include <cstdio>

    #include <cstring>

    #include <iostream>

    #include <string>

    #include <algorithm>

    #include <map>

    #include <vector>

    using namespace std;

    const int N = ;

    const int INF = 0x3f3f3f3f;  

    struct Node

    {

        int to;//终点

        int cap; //容量

        int rev;  //反向边

    };  

    vector<Node> v[N];

    bool used[N];  

    void add_Node(int from,int to,int cap)  //重边情况不影响

    {

        v[from].push_back((Node){to,cap,v[to].size()});

        v[to].push_back((Node){from,,v[from].size()-});

    }  

    int dfs(int s,int t,int f)

    {

        if(s==t)

            return f;

        used[s]=true;

        for(int i=;i<v[s].size();i++)

        {

            Node &tmp = v[s][i];  //注意

            if(used[tmp.to]==false && tmp.cap>)

            {

                int d=dfs(tmp.to,t,min(f,tmp.cap));

                if(d>)

                {

                    tmp.cap-=d;

                    v[tmp.to][tmp.rev].cap+=d;

                    return d;

                }

            }

        }

        return ;

    }  

    int max_flow(int s,int t)

    {

        int flow=;

        for(;;){

            memset(used,false,sizeof(used));

            int f=dfs(s,t,INF);

            if(f==)

                return flow;

            flow+=f;

        }

    }

    int main()

    {

        int n,m;

        while(~scanf("%d%d",&n,&m))

        {

            memset(v,,sizeof(v));

            for(int i=;i<n;i++)

            {

                int x,y,z;

                scanf("%d%d%d",&x,&y,&z);

                add_Node(x,y,z);

            }

            printf("%d\n",max_flow(,m));

        }

    }