#include<bits/stdc++.h>

using namespace std;

int st[],vis[],n,m,s,flow[],maxflow,t,x,y,z,tot=-,pre[],q[];

struct node

{

    int from,to,val,last;

/*

from记录起点

to记录重点

val记录这条边的流量

last记录起点和当前这条边的起点一样的边的序号

*/

}e[];

int mn(int x,int y)

{

    if(x>y)

        return y;

    return x;

}

void add(int f,int t,int v)

{//链式前向星

    tot++;//当前这条边的序号

    e[tot].from=f;

    e[tot].to=t;

    e[tot].val=v;

    e[tot].last=st[f];

    st[f]=tot;

    return ;

}

bool bfs(int s,int m)//寻找从起点到终点的路径

{

    int t=,h=;

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

    {

        vis[i]=-;//一开始把所有的点（包括起点和终点）标志为没有走过

        pre[i]=-;//记录上一条到达i点的边的起点的编号

    }

    t++;

    q[t]=s;//将起点入队

    vis[s]=;

    flow[s]=;

    while(t>=h)

    {

        int u=q[h];//拿出队首

        vis[u]=;//当前的队首标志为不在队列里

        h++;//踢出队首

        for(int i=st[u];i!=;i=e[i].last)

        {

            int v=e[i].to;

            if(e[i].val!= && vis[v]==-)//如果当前遍历到的点不在队列里（避免重复入队）就入队

            {

                flow[v]=mn(flow[u],e[i].val);//更新这条路径的流量（比较，求出最小值）

                pre[v]=i;//编号为i的这条边到达了v点，更新pre[v]

                t++;//入队

                q[t]=v; //将

                vis[v]=u;

            }

        }

    }

    if(vis[m]!=-)//从当前点s可以走到点m

        return true;

    return false;//如果运行到了这里，说明再也找不到从起点到终点的路了

}

void update(int s,int t)//一个回溯过程

{//如果能进这个函数，说明从当前点s可以走到点t

    int now=t;//从终点往回查找

    while(now!=s)//如果当前回溯到的点不是起点

    {//继续找

        int i=pre[now];

        e[i].val-=flow[t];//正向边加上这条边的流量

        e[i^].val+=flow[t];//建反向边，减去这条边的流量

        now=e[i].from;//更新当前回溯到的点

    }

    maxflow+=flow[t];//加上当前这条边的流量

}

void EK(int s,int t)

{

    maxflow=;//重置最大流

    while(bfs(s,t)==true)//如果当前找得到一条从起点到终点的路

        update(s,t);//加上这条路的流量

}

int main()

{

    scanf("%d %d %d %d",&n,&m,&s,&t);

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

    {

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

        add(x,y,z);//建正向边

        add(y,x,);//建反向边

    }

    EK(s,t);//求最大流

    printf("%d",maxflow);//输出

    return ;

}