POJ1273，Drainage Ditches（最大流问题）

网络流最大流问题， Dinic与ISAP模板题。
关于Dinic与ISAP的讲解可参考：
https://zhuanlan.zhihu.com/p/46039732
https://blog.csdn.net/qq_34374664/article/details/75394588
Dinic AC代码：

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<queue>
#include<cstring>
using namespace std;
const int maxn=2e2+5;
const int inf=0x7f7f7f7f;
typedef long long ll;

struct Dinic		//最大流Dinic算法，封装在结构体中 
{
	int s,t;		//源点，汇点 
	int dis[maxn];	//dis[]用于构造层次网络，表示顶点i到源点s的距离或相对s的层次 
	
	int head[maxn],cur[maxn],cnt;	// 以下用于构造链式前向星，cur[]是弧优化数组，用于优化算法（重要！） 
	struct Edge
	{
		int v,cap,next;
	}e[2*maxn];
	
	void add(int u,int v,int w)		//添加边 
	{
		e[cnt].v=v; e[cnt].cap=w; e[cnt].next=head[u]; head[u]=cnt++;		
		e[cnt].v=u; e[cnt].cap=0; e[cnt].next=head[v]; head[v]=cnt++; 		//反向边 
	}
	
	void init(int m)		//初始化 
	{
		memset(head,0,sizeof(head));
		cnt=2;		//注意！！！cnt不能从1开始！，下面会说明
		for(int i=1;i<=m;i++)
		{
			int u,v,c;
			scanf("%d%d%d",&u,&v,&c);
			add(u,v,c);
		}
	}
	
	bool bfs()		//BFS构造层次网络 
	{
		memset(dis,0,sizeof(dis));
		queue<int> Q;
		Q.push(s);
		dis[s]=1;
		while(!Q.empty())
		{
			int fro=Q.front(); Q.pop();
			for(int i=head[fro]; i ;i=e[i].next)
			{
				if(e[i].cap&&!dis[e[i].v])
				{
					Q.push(e[i].v);
					dis[e[i].v]=dis[fro]+1;
				}
			}
		}
		return dis[t]!=0;	//dis[t]=0说明此时已经没有从源点到汇点的路径，即不存在增广路了，整个Dinic算法可以结束 
	}
	
	int dfs(int pos,int flow)	//DFS在层次图中多次增广 
	{
		if(pos==t)	return flow;
		int ret=0;
		for(int i=cur[pos]; flow&&i ;i=e[i].next)
		{
			cur[pos]=i;
			if(e[i].cap&&dis[e[i].v]==dis[pos]+1)
			{
				int temp=dfs(e[i].v,min(e[i].cap,flow));
				if(temp>0)
				{
					e[i].cap-=temp;	//正向边
					e[i^1].cap+=temp;	//反向边
					flow-=temp;	//多次增广的关键 
					ret+=temp; 
				}
				else dis[e[i].v]=-1;
			}
		}
		return ret;
	}
	
	ll maxflow(int n)
	{
		ll ans=0;
		while(bfs())
		{
			for(int i=1;i<=n;i++)	cur[i]=head[i];
			ans+=dfs(s,inf);
		}
		return ans;
	}
}dinic;

int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m))
	{
		dinic.init(n);
		dinic.s=1; dinic.t=m;
		printf("%lld\n",dinic.maxflow(m));
	}
	return 0;
}

设有一个数x，若x为奇数，x^1=x-1； 若x为偶数，x^1=x+1。而我们要表示，2，3位一对正反边，4，5为一对正反边，因此cnt就要从2开始。（可以试试cnt=1自己推一下就会发现有错）。这个板子是搬上面知乎链接的，此处可能是答主手误，弄错了这个部分，本人是后面在使用模板过程中发现错误的。
PS：POJ这道题测试样例应该不严，即使cnt=1也能过，但放在其他地方就不行了。
ISAP AC代码：

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int inf=0x7f7f7f7f;
const int maxn=205;
struct ISAP		//据说ISAP算法效率要比Dinic算法好些 
{
	int s,t,dis[maxn];
	bool vis[maxn];
	int pre[maxn],cur[maxn],gap[maxn];	
	int head[maxn],cnt;
	struct	Edge
	{
		int from,to,cap,next;
	 }e[2*maxn];
	 
	 void addedge(int u,int v,int c)
	 { 
	 	e[cnt].from=u; e[cnt].to=v; e[cnt].cap=c; e[cnt].next=head[u]; head[u]=cnt++;
	 	e[cnt].from=v; e[cnt].to=u; e[cnt].cap=0; e[cnt].next=head[v]; head[v]=cnt++;
	 }
	 
	 void init(int m)
	 {
	 	memset(head,0,sizeof(head));
	 	cnt=2;
	 	for(int i=1;i<=m;i++)
	 	{
	 		int u,v,c;
	 		scanf("%d%d%d",&u,&v,&c);
	 		addedge(u,v,c);
		 }
	 }
	 
	 bool bfs()		//BFS反向构建层次图 
	 {
	 	memset(vis,0,sizeof(vis));
	 	queue<int> Q;
	 	Q.push(t);	
	 	vis[t]=1; dis[t]=0;
	 	while(!Q.empty())
	 	{
	 		int fro=Q.front(); Q.pop();
	 		for(int i=head[fro]; i ; i=e[i].next)
	 		{
	 			Edge& ed=e[i^1];
	 			if(!vis[ed.from])
	 			{
	 				vis[ed.from]=1;
	 				dis[ed.from]=dis[fro]+1;
	 				Q.push(ed.from);
				 }
			 }
		 }
		 return vis[s];
	 }
	 
	 int augment()	//增广
	 {
	 	int u=t, min_flow=inf;	//从汇点到源点反向增广 
	 	while(u!=s)
	 	{
	 		min_flow=min(min_flow,e[pre[u]].cap);
	 		u=e[pre[u]].from;
		 }
		u=t;
		while(u!=s)
		{
			e[pre[u]].cap-=min_flow;
			e[pre[u]^1].cap+=min_flow;
			u=e[pre[u]].from;
		}
		return min_flow;
	  } 
	
	int max_flow()
	{
		int flow=0;
		memset(gap,0,sizeof(gap));
		for(int i=0;i<maxn;i++)	cur[i]=head[i];
		bfs();		//BFS竟然只调用一次！ 
		for(int i=0;i<maxn;i++)	gap[dis[i]]++;	//gap优化
		int u=s;
		while(dis[s]<maxn)
		{
			if(u==t)
			{
				flow+=augment();
				u=s;
			}
			bool flag=0; 	//判断是否增广成功
			for(int i=cur[u]; i ;i=e[i].next)
			{
				Edge& ed=e[i];
				if(ed.cap&&dis[u]==dis[ed.to]+1)
				{
					flag=1;
					pre[ed.to]=i;
					cur[u]=i;
					u=ed.to;
					break;
				}
			 } 
			if(!flag)
			{
				int m=maxn-1;
				for(int i=head[u]; i ;i=e[i].next)
				{
					if(e[i].cap)
						m=min(m,dis[e[i].to]);
				}
				if(--gap[dis[u]]==0) break;
				gap[ dis[u]=m+1 ]++;
				cur[u]=head[u];
				if(u!=s)	u=e[pre[u]].from;
			}
		 } 
		return flow;
	}
}isap;

int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m))
	{
		isap.s=1; isap.t=m;
		isap.init(n);
		printf("%d\n",isap.max_flow());
	}
	return 0;
}

关于ISAP算法还有这个博客，讲得挺简单明了的。
https://blog.csdn.net/u014800748/article/details/44045073