Dinic Template

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
#define INF 0x7f7f7f7f
#define maxn 10000 + 10
struct Edge {
  	int from, to, cap, flow;
  	Edge(int u, int v, int c,int f):from(u), to(v), cap(c), flow(f){}
};
bool operator < (const Edge& a, const Edge& b) {
  	return a.from < b.from || (a.from == b.from && a.to < b.to);
}
struct Dinic {
	int n,m,s,t;
	vector<Edge> edges;vector<int> gr[maxn];          
	int d[maxn], cur[maxn]; bool vis[maxn]; 
	
	inline void ClearAll(int n) {
	    for(int i = 0; i < n; i++) gr[i].clear();
	    edges.clear();
	}
	inline void ClearFlow() {
	    for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;    
	}
	inline void AddEdge(int from, int to, int cap) {
	    edges.push_back((Edge){from, to, cap, 0});
	    edges.push_back((Edge){to, from, 0, 0});
	    m = edges.size();
	    gr[from].push_back(m-2);
	    gr[to].push_back(m-1);
	}
	
	inline bool BFS() {
	    memset(vis, 0, sizeof(vis));
	    queue<int> que;
	    que.push(s);
	    vis[s] = 1;
	    d[s] = 0;
	    while(!que.empty()) {
	      	int x = que.front(); que.pop();
	      	for(int i = 0; i < gr[x].size(); i++) 
			{
	        	Edge& e = edges[gr[x][i]];
	        	if(!vis[e.to] && e.cap > e.flow) {
	          		vis[e.to] = 1;
	          		d[e.to] = d[x] + 1;
	          		que.push(e.to);
	        	}
	      	}
	    }
	    return vis[t];
	}
	inline int DFS(int x, int a) {
	    if(x == t || a == 0) return a;
	    int flow = 0, f;
	    for(int& i = cur[x]; i < gr[x].size(); i++) {
	      	Edge& e = edges[gr[x][i]];
	      	if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0) {
	        	e.flow += f;
	        	edges[gr[x][i]^1].flow -= f;
	        	flow += f;
	        	a -= f;
	        	if(a == 0) break;
	      	}
	    }
	    return flow;
	}
	inline int Maxflow(int s, int t) {
	    this->s = s; this->t = t;
	    int flow = 0;
	    while(BFS()) {
	      	memset(cur, 0, sizeof(cur));
	      	flow += DFS(s, INF);
	    }
	    return flow;
	}
	inline vector<int> Mincut() { // call this after maxflow
	    vector<int> ans;
	    for(int i = 0; i < edges.size(); i++) {
	      Edge& e = edges[i];
	      if(vis[e.from] && !vis[e.to] && e.cap > 0) ans.push_back(i);
	    }
	    return ans;
	}
}g;

int main() {
//	freopen("dinic.in","r",stdin);
//	freopen("dinic.out","w",stdout);
  	int np,mp,sp,tp; scanf("%d%d%d%d",&np,&mp,&sp,&tp);
  	g.ClearAll(np);
  	while(mp --)
	{
	 	int u,v,c;scanf("%d%d%d",&u,&v,&c);
	 	g.AddEdge(u,v,c);
  	}
  	int flow = g.Maxflow(sp,tp);
  	printf("%d\n",flow);
  //	fclose(stdin);
  //	fclose(stdout);
 	return 0;
}