最大流 Dinic 算法实现的各种版本

最新推荐文章于 2019-07-23 17:20:58 发布
最新推荐文章于 2019-07-23 17:20:58 发布
阅读量1.6k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljd4305/article/details/9999501
版权

http://blog.csdn.net/hqd_acm/article/details/6648290  解决hdu的爆栈问题


测试了一下迭代+前向星 交 hdu 4280 7093ms 感觉还不错。


//递归+矩阵版本


#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int N=20;
const int INF=0x3f3f3f3f;
int s[N][N];//记录图的邻接矩阵
int d[N];//记录图中各点的层次
int n,m;
int min(int a,int b)
{
	return a<b?a:b;
}
bool bfs()
{
	queue<int>Q;
	memset(d,-1,sizeof(d));//此处初始化要特别注意，以上版本的初始化就存在很大问题
	d[1]=0;//如果处理不慎就很容易死循环
	Q.push(1);
	while(!Q.empty()){
		int v=Q.front();Q.pop();
		for(int i=1;i<=n;i++){
			if(d[i]==-1&&s[v][i]){//此处应是s[v][i]!=0,而不是以上版本中的s[v][i]>0,因为dfs是可能会走错，这样可以对其进行修正。
				d[i]=d[v]+1;
				Q.push(i);
			}
		}
	}
	return d[n]!=-1;
}
int dfs(int v,int cur_flow)
{
	int dt=cur_flow;
	if(v==n)return cur_flow;
	for(int i=1;i<=n;i++){
		if(s[v][i]>0&&d[v]+1==d[i]){
			int flow=dfs(i,min(dt,s[v][i]));//在下一层中继续搜路，直到终点
			s[v][i]-=flow;
			s[i][v]+=flow;
			dt-=flow;//找到一条路，存起来
		}
	}
	return cur_flow-dt;//从这一点可以流出多少流量
}
int dinic()
{
	int cur_flow,ans=0;
	while(bfs()){//一次bfs可以找到几条增广路
		while(cur_flow=dfs(1,INF))
			ans+=cur_flow;
	}
	return ans;
}
int main()
{
	int t,i,cas=0,u,v,w;
	scanf("%d",&t);
	while(t--){
		memset(s,0,sizeof(s));
		scanf("%d %d",&n,&m);
		for(i=1;i<=m;i++){
			scanf("%d %d %d",&u,&v,&w);
			if(u==v)continue;
			s[u][v]+=w;
		}
		printf("Case %d: %d\n",++cas,dinic());
	}
	return 0;
}

//递归+前向星版 

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int N=100010;
const int INF=0x3f3f3f3f;
const int MIN = -0xfffffff;
const int MAX = 0xfffffff;
//int s[N][N];//记录图的邻接矩阵
int d[N];//记录图中各点的层次
int n,m, S, T, num;
int head[N];

struct Edge{
    int s,e,v,next;
}edge[2*N];

void init(int a,int b,int c){
    edge[num].s = a;
    edge[num].e = b;
    edge[num].v = c;
    edge[num].next = head[a];
    head[a] = num++;
}

void add(int a,int b,int c){
    init(a,b,c);
    init(b,a,c);
}

int min(int a,int b)
{
	return a<b?a:b;
}
bool bfs()
{
	queue<int>Q;
	memset(d,-1,sizeof(d));//此处初始化要特别注意，以上版本的初始化就存在很大问题
	d[S]=0;//如果处理不慎就很容易死循环
	Q.push(S);
	while(!Q.empty()){
		int v=Q.front();Q.pop();
		for(int i=head[v];i != -1;i = edge[i].next){
		    int u = edge[i].e;
			if(d[u]==-1&&edge[i].v>0){//此处应是s[v][i]!=0,而不是以上版本中的s[v][i]>0,因为dfs是可能会走错，这样可以对其进行修正。
				d[u]=d[v]+1;
				Q.push(u);
			}
		}
	}
	return d[T]!=-1;
}

int dfs(int v,int cur_flow)
{
	int dt=cur_flow;
	if(v==T)return cur_flow;
	for(int i=head[v];i != -1;i = edge[i].next){
	    int u = edge[i].e;
		if(edge[i].v>0&&d[v]+1==d[u]){
			int flow=dfs(u,min(dt,edge[i].v));//在下一层中继续搜路，直到终点
			edge[i].v -= flow;
			edge[i^1].v += flow;
			dt-=flow;//找到一条路，存起来
		}
	}
	//cout<<"1"<<endl;
	return cur_flow-dt;//从这一点可以流出多少流量
}
int dinic()
{
	int cur_flow,ans=0;
	while(bfs()){//一次bfs可以找到几条增广路
		while(cur_flow=dfs(S,INF))
			ans+=cur_flow;
	}
	return ans;
}
int main()
{
	int t,i,cas=0,u,v,w;
	scanf("%d",&t);
	while(t--){
	    scanf("%d%d",&n,&m);
		//memset(s,0,sizeof(s));
		int west=MAX,east=MIN,x,y;
		for(i= 1; i <= n; i++){
            scanf("%d%d",&x,&y);
            if(x<west)west = x, S = i;
            if(x>east)east = x, T = i;
		}
		num = 0;
		memset(head,-1,sizeof(head));
		for(i=1;i<=m;i++){
			scanf("%d%d%d",&u,&v,&w);
			if(u==v)continue;
			add(u,v,w);
		}
		//cout<<S<<"-"<<T<<endl;
		printf("%d\n",dinic());
	}
	return 0;
}

//迭代+前向星版 hdu 4280 代码 


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int N=100010;
const int INF=0x3f3f3f3f;
const int MIN = -0xfffffff;
const int MAX = 0xfffffff;
//int s[N][N];//记录图的邻接矩阵
int d[N];//记录图中各点的层次
int n,m, S, T, num;
int head[N];

struct Edge{
    int s,e,v,next;
}edge[2*N];

int stack[N];
int cur_head[N];
int que[N];

void init(int a,int b,int c){
    edge[num].s = a;
    edge[num].e = b;
    edge[num].v = c;
    edge[num].next = head[a];
    head[a] = num++;
}

void add(int a,int b,int c){
    init(a,b,c);
    init(b,a,c);
}

int min(int a,int b)
{
	return a<b?a:b;
}
bool bfs()
{
	queue<int>Q;
	memset(d,-1,sizeof(d));//此处初始化要特别注意，以上版本的初始化就存在很大问题
	d[S]=0;//如果处理不慎就很容易死循环
	Q.push(S);
	while(!Q.empty()){
		int v=Q.front();Q.pop();
		for(int i=head[v];i != -1;i = edge[i].next){
		    int u = edge[i].e;
			if(d[u]==-1&&edge[i].v>0){//此处应是s[v][i]!=0,而不是以上版本中的s[v][i]>0,因为dfs是可能会走错，这样可以对其进行修正。
				d[u]=d[v]+1;
				Q.push(u);
			}
		}
	}
	return d[T]!=-1;
}
int BFS()
{
    int i;
    int front=0,real=0;
    memset(d,-1,sizeof(d));
    que[real++] = S;
    d[S] = 0;
    while(front != real)
    {
        int u = que[front++];
        front = front%N;
        for(i = head[u];i != -1;i = edge[i].next)
        {
            int v = edge[i].e;
            if(edge[i].v > 0 && d[v] == -1)
            {
                d[v] = d[u] + 1;
                que[real++] = v;
                real = real%N;
                if(v == T)
                    return 1;
            }
        }
    }
    return 0;
}

int dfs(int v,int cur_flow)
{
	int dt=cur_flow;
	if(v==T)return cur_flow;
	for(int i=head[v];i != -1;i = edge[i].next){
	    int u = edge[i].e;
		if(edge[i].v>0&&d[v]+1==d[u]){
			int flow=dfs(u,min(dt,edge[i].v));//在下一层中继续搜路，直到终点
			edge[i].v -= flow;
			edge[i^1].v += flow;
			dt-=flow;//找到一条路，存起来
		}
	}
	//cout<<"1"<<endl;
	return cur_flow-dt;//从这一点可以流出多少流量
}

int find_max_flow(){
    int cur = S;
    int max_flow = 0, limit;
    int top = 0;
    memcpy(cur_head,head,sizeof(head));

    while(1){
        if(cur == T){
            limit = MAX;
            int back;
            for(int i = 0; i < top; i++){
                if(edge[stack[i]].v < limit){
                    limit = edge[stack[i]].v;
                    back = i;
                }
            }
            for(int i = 0; i < top; i++){
                edge[stack[i]].v -= limit;
                edge[stack[i]^1].v += limit;
            }
            max_flow += limit;
            top = back;
            cur = edge[stack[top]].s;
        }
        for(int i = cur_head[cur]; i != -1; i = cur_head[cur] = edge[i].next){
            if(edge[i].v != 0 && d[cur] == d[edge[i].e] - 1){
                break;
            }
            //cout<<"!"<<endl;
        }
        if(cur_head[cur] != -1){
            stack[top++] = cur_head[cur];
            cur = edge[cur_head[cur]].e;
        }
        else {
            if(top == 0){
                break;
            }
            d[cur] = -1;
            cur = edge[stack[--top]].s;
        }
        //cout<<"!"<<endl;
    }//cout<<"!"<<endl;
    return max_flow;
}

int dinic()
{
	int cur_flow,ans=0;
	while(BFS()){//一次bfs可以找到几条增广路
		while(cur_flow=find_max_flow())
			ans+=cur_flow;
	}
	return ans;
}
int main()
{
	int t,i,cas=0,u,v,w;
	scanf("%d",&t);
	while(t--){
	    scanf("%d%d",&n,&m);
		//memset(s,0,sizeof(s));
		int west=MAX,east=MIN,x,y;
		for(i= 1; i <= n; i++){
            scanf("%d%d",&x,&y);
            if(x<west)west = x, S = i;
            if(x>east)east = x, T = i;
		}
		num = 0;
		memset(head,-1,sizeof(head));
		for(i=1;i<=m;i++){
			scanf("%d%d%d",&u,&v,&w);
			if(u==v)continue;
			add(u,v,w);
		}
		//cout<<S<<"-"<<T<<endl;
		printf("%d\n",dinic());
	}
	return 0;
}






娜一笑最倾城
关注
网络流——Dinic算法求最大流
Lucas_FC_的博客
08-27 546
Dinic算法求最大流
网络流dinic算法
蒟蒻こんにゃく
07-28 860
是什么是网络流 在一个有向图上选择一个源点，一个汇点，每一条边上都有一个流量上限（以下称为容量），即经过这条边的流量不能超过这个上界，同时，除源点和汇点外，所有点的入流和出流都相等，而源点只有流出的流，汇点只有汇入的流。这样的图叫做网络流。 一些定义 源点：只有流出去的点 汇点：只有流进来的点 流量：一条边上流过的流量 容量：一条边上可供流过的最大流量 残量：一条边上的容量-流量 网络流最大流 定义 网络流的最大流算法就是指的一个流量的方案使得网络中流量最大。 网络流最大流求解 网络流的所有算法都是基于一种
最大流dinic算法
12-06
Dinic算法的基本思路: 1.根据残量网络计算层次图。 2.在层次图中使用DFS进行增广直到不存在增广路 3.重复以上步骤直到无法增广
最大流模板（Dinic）
weixin_30568715的博客
05-30 116
最大流模板： #include<stdio.h> #include<iostream> using namespace std; const int oo=1e9; /**oo 表示无穷大*/ const int mm=111111111; /**mm 表示边的最大数量，记住要是原图的两倍，在加边的时候都是双向的*/ const i...
最大流算法之Dinic
weixin_30570101的博客
04-09 184
引言： 在最大流（一）中我们讨论了关于EK算法的原理与代码实现，此文将讨论与EK算法同级别复杂度（O（N^2M））的算法——Dinic算法。 Dinic算法用到的思想是图的分层结构，通过BFS将每一个节点标出层次后DFS得到当前增广路。然后继续在残留网络中进行BFS分层，当汇点不在层次网络时（没有连通弧了），算法结束。 Dinic算法结构： 0.初始化（边表） 1.BFS...
最大流dinic
NLSQQ的博客
07-22 262
基本思路：在求图的最大流时，首先用bfs把图分层，分层时注意流量是否大于零，和该点是否已分层。每一次分层都需要重置level数组，如果分层后，终点没有被分层，说明没有增广路了，，之后用dfs进行增广路搜索，如果流量不为零， 并且该节点到下一个节点，正好为差为1，就在可以在搜索增广路，如果增广路搜索到的流量大于零，就要构建残余网络，就返回该流量，若找不到返回零。 #include#incl
最大流Dinic
一切顺其自然
12-06 270
复杂度O(V2E)O(V^2E)O(V2E) const int maxn=2e3+100; const int INF=0x3f3f3f3f; ll n,m,tol,head[maxn]; struct edge{ ll to,next,w; }a[maxn*10]; void init(){ memset(head,-1,sizeof head); tol=1; } inl...
network-flow:最大流的 Dinic 算法的 C++ 实现
06-04
最大流的 Dinic 算法的 C++ 实现。 以下是操作摘要： FlowNetwork f(n, m) ：具有 n 个顶点（0 到 n-1）和 m 个有向边的新网络， f.add(x, y, c) ：添加从节点 x 到节点 y 的有向边，容量为 c， f.flow(s, t) ：...
最大网络流Dinic算法
09-01
总结起来，Dinic算法是解决最大网络流问题的一种高效方法，通过层次结构和增广路径的概念，能够在保证正确性的前提下，实现较好的运行效率。在实际应用中，它可以用于解决资源分配、调度、通信网络流量规划等问题。
Dinic.rar_Dinif2.m_dinic_最大流_最大流算法_最大网络流
07-15
本文将详细介绍Dinic算法，这是一种高效的求解网络最大流的算法。 首先，我们要理解什么是最大流。在网络流问题中，我们有一个带权重的有向图，其中每个边代表一个可以传输流量的连接，每条边都有一个容量限制。...
关于Dinic算法的c++编程
04-08
该Dinic算法是采用的是DFS进行分层和DFS进行路径的扩展，其效率较高。
最大流Dinic模板
代码中转站
04-27 451
const int N=210; const int M=40010*2; const int inf=0x3f3f3f3f; struct Edge { int v,cap,nxt; }e[M]; int src,des,dis[N],head[N],ecnt; int n,m; void Addedge(int u,int v,int w) {     e[ecnt].v=v;
最大流 Dinic算法
Sdywolf的博客
10-31 327
dinic算法的主体是利用DFS来求增广路。可以理解成从源节点倒无穷多的水下去，看看最后有多少能够流倒汇。配合当前弧优化，dinic算法的效率还是不错的。代码#include<cstdio> #include<cstring> #include<algorithm> #define maxn 10006 #define maxe 200006 #define INF 1000000000 using
最大流dinic模板
wuxiaowu547的博客
08-04 301
#include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;queue&gt; #define inf 0x3f3f3f3f3f3f3f3f #define ll long long #define MAXN 10005 using namespace std; int n,m;//...
Dinic 最大流
lalala445566的博客
03-06 568
我的博客地址: https://startcraft.cn 概述 dinic算法是网络流中的一种算法，这里拿来求最大流 所谓最大流就是一个网络中的最大流量，如下面这个图片 其中A称作源点，B称为汇点，边上的数字代表这条边最多能容纳多大的流量，所以上图的最大流量为12 dinic算法就是求最大流算法的一种 反向边概念 大部分网络流的算法都会在建边是建立一条反向边，初始权值为0，可以理解为给算法后...
最大流——Dinic算法
weixin_34318272的博客
08-12 144
1、Dinic算法思路 Dinic算法的思想也是分阶段地在层次网络中增广。它与最短增广路算法不同之处是：最短增广路每个阶段执行完一次BFS增广后，要重新启动BFS从源点Vs开始寻找另一条增广路;而在Dinic算法中，只需一次DFS过程就可以实现多次增广，这是Dinic算法的巧妙之处。Dinic算法具体步骤如下: （1）初始化容量网络和网络流。 （2）构造残留网络和层次网络，若汇点不再层次网络...
最大流（Dinic算法）
百般回首曾经的相遇，留下的只是一缕残忆
07-23 2939
Dinic算法 简介： 相较 Edmonds-Karp 算法而言，为防止每进行一次增广，都要做一遍BFS，时间复杂度过高，用于减少所作 BFS 次数。 因而 Dinic 算法在 EK 算法的基础上增加了分层图的概念，根据从s到各个点的最短距离的不同，把整个图分层。 过程： 先利用BFS对残余网络分层，一个节点的深度，就是源点到它最少要经过的边数。 利用BFS对残余网络分层，分完层后，利用DFS从...
Dinic算法详解：高效最大流实现
Dinic算法是一种高效求解网络最大流问题的算法，由苏联数学家Julii Dinitz在1970年提出。网络最大流问题通常描述为在一个有向图中，从一个源点到一个汇点寻找最大流量的过程，其中每条边都有一定的容量限制。Dinic...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值