最大流算法

EK算法，复杂度（V*E*E）

#define min(a,b) a<b?a:b
#define inf 0x3f3f3f3f
using namespace std;

const int maxn=250;
int edgenum,nodenum;
int cap[maxn][maxn];
int pre[maxn];
bool vis[maxn];
//不要忘了初始化cap[][]=0
void init()
{
	for(int i=0;i<maxn;i++)
	{
		pre[i]=-1;
		vis[i]=false;
//		for(int j=0;j<maxn;j++)
//			cap[i][j]=0;
	}
}

bool BFS(int s,int t)
{
	init();
	queue<int>que;
	vis[s]=true;
	pre[s]=s;
	que.push(s);
	while(!que.empty())
	{
		int p=que.front();
		que.pop();
		for(int i=1;i<=nodenum;i++)
		{
			if(cap[p][i]>0&&!vis[i])
			{
				pre[i]=p;
				vis[i]=true;
				if(i==t)
					return true;
				que.push(i);

			}
		}
	}
	return false;
}
//pre[i]记录的是i的前一个节点，所以在循环的时候从汇点向源点扫
int EK(int s,int t)
{
	int maxflow=0,d;
	while(BFS(s,t))
	{
		d=inf;
		for(int i=t;i!=s;i=pre[i])
		{
			d=min(d,cap[pre[i]][i]);
		}
		//修改残余网络，注意正向边和反向边都要修改
		for(int i=t;i!=s;i=pre[i])
		{
			cap[pre[i]][i]-=d;
			cap[i][pre[i]]+=d;
		}
		maxflow+=d;
	}
	return maxflow;
}

Dinic 复杂度（V*V*E）；

#define min(a,b)a<b?a:b
#define inf 0x3f3f3f3f
using namespace std;

const int maxn=300;
int level[maxn];
int head[maxn];
struct Edge{
	int to,next,f;
}edge[maxn*maxn];
int nodenum,edgenum;
int egnum;
void addedge(int u,int v,int val)
{
	edge[egnum].to=v;
	edge[egnum].f=val;
	edge[egnum].next=head[u];
	head[u]=egnum++;
	//反向边,一定要注意反向边的添加和其流量的认定。
	edge[egnum].to=u;
	edge[egnum].f=0;//方向边的流量是0；
	edge[egnum].next=head[v];
	head[v]=egnum++;
}
//分层
bool BFS(int s,int t)
{
	memset(level,0,sizeof(level));
	level[s]=1;
	queue<int>que;
	que.push(s);
	while(!que.empty())
	{
		int tp=que.front();
		que.pop();
		if(tp==t)
			return true;
		for(int i=head[tp];i!=-1;i=edge[i].next)
		{
			if(!level[edge[i].to]&&edge[i].f)
			{
				que.push(edge[i].to);
				level[edge[i].to]=level[tp]+1;
			}
		}
	}
	return false;
}

int DFS(int now,int maxF,int t)
{
	if(now==t)return maxF;
	int ret=0,f;
	int k;
	for(k=head[now];k!=-1;k=edge[k].next)
	{
		if(edge[k].f&&level[edge[k].to]==level[now]+1)
		{
			f=DFS(edge[k].to,min(maxF-ret,edge[k].f),t);
			edge[k].f-=f;
			edge[k^1].f+=f;
			ret+=f;
			if(ret==maxF)return ret;
		}
	}
	return ret;

}

int Dinic(int s,int t)
{
	int ans=0;
	while(BFS(s,t))ans+=DFS(s,inf,t);
	return ans;

}

SAP（V*V*E）

#define min(a,b)a<b?a:b
#define inf 0x3f3f3f3f
using namespace std;

const int maxn=250;
const int maxm=maxn*maxn;
int nodenum,edgenum;
int head[maxn];
struct Node {
	int c,next,to;
}edges[maxm];
int tot;
void init()
{
	tot=0;
	for(int i=0;i<maxn;i++)
		head[i]=-1;
}
void addedge(int st,int ed,int val)
{
	edges[tot].c=val;
	edges[tot].to=ed;
	edges[tot].next=head[st];
	head[st]=tot++;

	edges[tot].c=0;
	edges[tot].to=st;
	edges[tot].next=head[ed];
	head[ed]=tot++;
}
int SAP(int start,int end,int N)
{
	int numh[maxn],h[maxn],curedges[maxn],pre[maxn];
	int cur_flow,flow_ans=0,u,tmp,neck,i;
	for(i=0;i<maxn;i++)
	{
		h[i]=0;
		numh[i]=0;
		pre[i]=-1;
	}
	for(i=1;i<=N;i++)//此处是遍历所有的边，全包括
	{
		curedges[i]=head[i];//将当前弧初始化为第一条邻接边
	}
	numh[0]=N;
	u=start;
	while(h[start]<N)//当h[start]>=N时，网络中肯定出现了GAP
	{
		if(u==end)
		{
			cur_flow=inf;
			for(i=start;i!=end;i=edges[curedges[i]].to)
			{
				if(cur_flow>edges[curedges[i]].c)
				{
					neck=i;
					cur_flow=edges[curedges[i]].c;
				}
			}//寻找瓶颈边
			for(i=start;i!=end;i=edges[curedges[i]].to)
			{
				tmp=curedges[i];
				edges[tmp].c-=cur_flow;
				edges[tmp^1].c+=cur_flow;
			}//修改路径上的边容量
			flow_ans+=cur_flow;
			u=neck;//下次增广从瓶颈边开始
		}
		for(i=curedges[u];i!=-1;i=edges[i].next)
		{
			if(edges[i].c&&h[u]==h[edges[i].to]+1)
			{
				break;//寻找可行弧
			}
		}
		if(i!=-1)
		{
			curedges[u]=i;
			pre[edges[i].to]=u;
			u=edges[i].to;
		}
		else
		{
			if(0==--numh[h[u]])
				break;//GAP优化
			curedges[u]=head[u];
			for(tmp=N,i=head[u];i!=-1;i=edges[i].next)
			{
				if(edges[i].c)
					tmp=min(tmp,h[edges[i].to]);
			}
			h[u]=tmp+1;
			++numh[h[u]];
			if(u!=start)u=pre[u];
		}
	}
	return flow_ans;
}