网络流学习笔记

还在施工之中,先将就着看着吧

网络流中关于反向边的个人理解

建反向边的目的是，在你下一次找增广路的时候，沿着反向边走的流量就代表之前走这条路的那条增广路要回退多少，而这一次走的流量就顺着上一次的增广路把回退流量补上，而那些回退的流量就再去找别的路径

就像这样，路径2挤掉了路径1的2的流量，继续沿着路径1的线路走

而路径1被挤掉的流量就要回到上一个节点重新找路径

有点像反悔贪心

点击查看 网络流 EK算法 模板

#include<bits/stdc++.h>
using namespace std;
int n,m,s,t;//s为源点,t为汇点
struct edge
{
	int f,t;
	long long  c;//流量上限
};
edge edges[100000];
int cnt=1;//存边数，初始为1是为了后续取反边 
struct node
{
	long long  mf;//max_f 从 S 出发到这个点最大流量上限
	vector<int> to;//存出边
	int pre;//前驱边
};
node nodes[100000];
bool bfs()
{
	for(int yy=1; yy<=n; yy++)
	{
		nodes[yy].mf=0;//清空流量数组 
	}
	queue<int> q;//队列 
	q.push(s);//源点入队 
	nodes[s].mf=1e9;//标记源点的水流为无限大 
	while(!q.empty()) 
	{
		int now_=q.front();//现在在那个节点 
		q.pop();
		int to,edg;
		for(int k=0; k<nodes[now_].to.size(); k++)//遍历所有出边 
		{
			edg=nodes[now_].to[k];//现在在哪条边 
			to=edges[edg].t;//去到哪个节点 
			if(nodes[to].mf==0&&edges[edg].c)//如果要去的节点没被去过并且这条边的流量不为 0 
			{
				nodes[to].mf=min(nodes[now_].mf,edges[edg].c);//记录要去的节点的流量 
				nodes[to].pre=edg;//记录是从哪条边流过来的流量 
				q.push(to);//将要去的节点入队 
				if(to==t)//如果抵达汇点 
				{
					return 1;
				}
			}
		}
	}
	return 0;//到不了汇点 
}
long long  e_k()//EK 算法 
{
	long long  tot_f=0;//总流量 
	while(bfs())//如果还有增广路 
	{
		int now_=t;//现在在那个节点 
		while(now_!=s)//如果还没有回到原点 
		{
			int edg=nodes[now_].pre;//这个节点的流量是从哪条边来的 
			edges[edg].c-=nodes[t].mf;//将正边剩余流量减去这一条增广路的流量 
			edges[edg^1].c+=nodes[t].mf;//将反向边加上这一条增广路的流量 
			now_=edges[edg^1].t;//继续向前 
		}
		tot_f+=nodes[t].mf;//总流量加上这一条增广路的流量 
	}
	return tot_f;
}
int main()
{
	ios::sync_with_stdio(0);
	cin>>n>>m>>s>>t;
	long long a,b,c;
	for(int ww=1; ww<=m; ww++)
	{
		cin>>a>>b>>c;
		edges[++cnt].c=c;
		edges[cnt].f=a;
		edges[cnt].t=b;
		nodes[a].to.push_back(cnt);
		edges[++cnt].c=0;//建反向边，初始流量为零 
		edges[cnt].f=b;
		edges[cnt].t=a;
		nodes[b].to.push_back(cnt);
	}
	cout<<e_k();//跑EK算法 
	return 0;
}

点击查看 网络流 Dinic算法 板子

#include<bits/stdc++.h>
using namespace std;
struct edge
{
	long long  c;//每条边的剩余流量 
	int f,t;
};
edge edges[100000];
int cnt=1;//边数从1开始 
struct node
{
	long long mf;//最小的流量 
	int num;//
	int cur;//当前弧优化 
	vector<int> to;
	int d;//节点深度，层数
};
node nodes[100000];
int n,m,s,t;

inline bool bfs()//分层用的bfs 
{
	for(int ww=1; ww<=n; ww++)//将节点层数清空 
	{
		nodes[ww].d=0;
	}
	queue<int> q;//队列 
	q.push(s);
	nodes[s].d=1;
	int to,now_,edg;
	while(!q.empty())//队列不为空 
	{
		now_=q.front();
		q.pop();
		for(int i=0; i<nodes[now_].to.size(); i++)
		{
			edg=nodes[now_].to[i];
			to=edges[edg].t;
			if(nodes[to].d==0&&edges[edg].c)
			{
				nodes[to].d=nodes[now_].d+1;
				q.push(to);
				if(to==t)
				{
					return 1;

				}
			}
		}
	}
	return 0;
}
inline long long dfs(int now_,long long mf)
{
	if(now_==t)//如果到了汇点 
	{
		return mf;
	}
	long long sum=0;
	int edg,to;
	for(int i=nodes[now_].cur; i<nodes[now_].to.size(); i++)
	{
		edg=nodes[now_].to[i];//当前弧优化 
		nodes[now_].cur=i;
		to=edges[edg].t;
		if(nodes[to].d==nodes[now_].d+1&&edges[edg].c)//如果在下一层 
		{
			long long f=dfs(to,min(mf,edges[edg].c));//算出流量 
			edges[edg].c-=f;
			edges[edg^1].c+=f;
			sum+=f;//
			mf-=f;//将剩余流量减去这个流量 
			if(mf==0)//优化残量优化 
			{
				break;
			}
		}
	}
	if(sum==0)//如果没有任何更多的流量 
	{
		nodes[now_].d=0;//将这个节点删去 
	}
	return sum;
}
long long dinic()
{
	long long  tot_f=0;
	while(bfs())//如果还有增广路的话 
	{
		for(int yy=1;yy<=n;yy++)
		{
			nodes[yy].cur=0;//将当前弧清空 
		}
		tot_f+=dfs(s,1e9);//加上新流量 
	}
	return tot_f;
}
int main()
{
	ios::sync_with_stdio(0);
	cin>>n>>m>>s>>t;
	long long  a,b,c;
	for(int ee=1; ee<=m; ee++)
	{
		cin>>a>>b>>c;
		edges[++cnt].f=a;
		edges[cnt].t=b;
		edges[cnt].c=c;
		nodes[a].to.push_back(cnt);
		edges[++cnt].f=b;
		edges[cnt].t=a;
		edges[cnt].c=0;
		nodes[b].to.push_back(cnt);
	}
	cout<<dinic();
	return 0;
}