程序博客网 > java怎样创建服务

网络流算法整理

来源：互联网 发布：java怎样创建服务 编辑：程序博客网 时间：2024/06/05 14:54

(转自http://blog.csdn.net/wangjian8006/article/details/7939599)

EK(EdmondsKarp)算法：这个算法改进于Ford-Fulkerson算法，Ford-Fulkerson算法是不断用广搜找一条增广路，然后判断一次这条路的最小流量，再对这条路增流，而EK与FF算法不同的是用一个数组记录了广搜之后增广路的最小流量，然后再根据父亲数组去增流,时间复杂度为O(VE^2)

 

[cpp] view plaincopy
  1. typedef struct{  
  2.     int flow;           //流量  
  3.     int capacity;       //最大容量值  
  4. }maps;  
  5.   
  6. maps map[MAXV][MAXV];  
  7.   
  8. int maxflow;                //最大流  
  9. int sp,fp;              //标记源点与汇点  
  10. int parent[MAXV];           //用于bfs寻找路径  
  11. int vertime;                //顶点总数  
  12.   
  13. int bfs(int start,int end){  
  14.     int a[MAXV],i,v;  
  15.     queue <int>q;  
  16.   
  17.     memset(a,0,sizeof(a));              //记录增广路最小流量，而且又可以当做广搜的标记数组  
  18.     memset(parent,-1,sizeof(parent));       //记录下这条增广路，以便增流  
  19.       
  20.     q.push(start);  
  21.     a[start]=MAXINT;  
  22.     while(!q.empty()){  
  23.         v=q.front();q.pop();  
  24.         for(i=1;i<=vertime;i++){  
  25.             if(!a[i] && map[v][i].capacity>map[v][i].flow){      //如果这是一条允许弧就记录下来  
  26.                 q.push(i);  
  27.                 parent[i]=v;  
  28.                 a[i]=min(a[v],map[v][i].capacity-map[v][i].flow);  
  29.             }  
  30.         }  
  31.         if(v==end) break;               //找到增广路退出  
  32.     }  
  33.     return a[end];  
  34. }  
  35. void EdmondsKarp(){  
  36.     int i,tmp;  
  37.     maxflow=0;  
  38.     while(tmp=bfs(sp,fp)){  
  39.         for(i=fp;i!=sp;i=parent[i]){                //根据父亲数组更新流量  
  40.             map[i][parent[i]].flow-=tmp;            //更新反向流  
  41.             map[parent[i]][i].flow+=tmp;            //更新正向流  
  42.         }  
  43.         maxflow+=tmp;  
  44.     }  
  45. }  


 

SAP(最短增广路)：先简单的描述一下SAP的过程:
首先根据可行弧（容量>流量）分层，汇点为第0层，源点为d[s]层                          
          ........①
分层之后，不断从源点搜索增广路，按允许弧(容量>流量，并且由v指向u的一条弧满足d[v]=d[u]+1)搜索，也就是说前面的层数比后面层数

小1，这样搜索出来的一条增广路满足最短增广路。        
          ........②
当从源点出发找不到一条增广路之后，使最后那条可行流的所指的顶点层数加1，再从源点开始搜索，即进行第②步操作。
          ........③
当从源点出发找到一条增广路，对这条增广路增流之后，再从源点出发找增广路，即进行第2步操作。
          ........④
当满足d[s]>n-1则退出搜索，因为图为n个节点，从0开始最多n-1层，如果d[s]大于n-1层，则中间出现断层，就找不到那么一条增广路了。
          ........⑤
这样分析这个算法的复杂度，网络中最多m条边，做多可以增广m次，用BFS增广，一次增广的复杂度为O(m+n)，其中O(m)为BFS的花费，O(n)

为修改流量的花费，所以在每一个阶段寻找增广路的复杂度为O(m×(m+n))=O(m^2)，因此n个阶段寻增广路的复杂度为O(n×m^2).
综上所述，最短增广路算法的总复杂度即为建层次网络的总复杂度与寻找增广路的总复杂度之和，为O(n×m^2)

[cpp] view plaincopy
  1. int n;                              //点的总数  
  2. int c[MAXV][MAXV];                      //容量  
  3. int r[MAXV][MAXV];                      //残量  
  4. int source,sink;                        //源点与汇点  
  5. int dis[MAXV],maxflow;                      //分层数组与最大流  
  6.   
  7. void bfs(){  
  8.     int v,i;  
  9.     queue <int>q;  
  10.     memset(dis,0,sizeof(dis));  
  11.     q.push(sink);                       //汇点为0层  
  12.     while(!q.empty()){  
  13.         v=q.front();q.pop();  
  14.         for(i=0;i<=sink;i++){  
  15.             if(!dis[i] && c[i][v]>0){  
  16.                 dis[i] = dis[v] +1;  
  17.                 q.push(i);  
  18.             }  
  19.         }  
  20.     }  
  21. }  
  22.   
  23. void sap(){  
  24.     int top=source,pre[MAXV],i,j,low[MAXV];  
  25.   
  26.     bfs();                              //分层  
  27.     memset(low,0,sizeof(low));              //保存路径的最小流量  
  28.     while(dis[source]<n){  
  29.         low[source]=INF;  
  30.         for(i=0;i<=sink;i++){            //找到一条允许弧  
  31.             if(r[top][i]>0 && dis[top]==dis[i] +1) break;  
  32.         }  
  33.         if(i<=sink){                 //找到了允许弧  
  34.             low[i]=min(r[top][i],low[top]);     //更新当前的最小流量  
  35.             pre[i]=top;top=i;               //记录增广路径  
  36.             if(top==sink){              //找到一条增广路径更新残量  
  37.                 maxflow+=low[sink];  
  38.                 j=top;  
  39.                 while(j != source){  
  40.                     i=pre[j];  
  41.                     r[i][j]-=low[sink];  
  42.                     r[j][i]+=low[sink];  
  43.                     j=i;  
  44.                 }  
  45.                 top=source;             //再从头找一条增广路径  
  46.             }  
  47.         }  
  48.         else{                           //找不到这样一条允许弧更新距离数组  
  49.             int mindis=INF;  
  50.             for(j=0;j <=sink;j++){  
  51.                 if(r[top][j]>0 && mindis>dis[j] +1)  
  52.                     mindis=dis[j] +1;  
  53.             }  
  54.             dis[top]=mindis;                //更新最后那个阻塞流节点的层数  
  55.             if(top!=source) top=pre[top];  
  56.         }  
  57.     }  
  58. }  

 

运用gap优化：
即当标号中出现了不连续标号的情况时，即可以证明已经不存在新的增广流，此时的流量即为最大流。
简单证明下：
假设不存在标号为k的结点，那么这时候可以将所有的结点分成两部分，一部分为d（i）>k,另一部分为d（i）<k
如此分成两份，因为性质2可知，允许路为最短的增广路，又因为不存在从>k部分到<k部分的增广流，那么有最大流最小割定理可知此时便是

最大流。
sap+gap+邻接矩阵

[cpp] view plaincopy
  1. #define INF INT_MAX  
  2. #define min(a,b) (a>b?b:a)  
  3.   
  4. //n为总点数  
  5. int sink,source,res[MAXV][MAXV],n;  
  6. int pre[MAXV],dis[MAXV],gap[MAXV],maxflow,cur[MAXV];  
  7.   
  8. int sap(){  
  9.     int s=source,t=sink;  
  10.     memset(cur,0,sizeof(cur));  
  11.     memset(dis,0,sizeof(dis));  
  12.     memset(gap,0,sizeof(gap));  
  13.   
  14.     int u=pre[s]=s,aug=INF,v;  
  15.     maxflow=0;  
  16.     gap[source]=n;  
  17.   
  18.     while(dis[s]<n){  
  19. loop:  
  20.     for(v=cur[u];v<n;v++)  
  21.         if(res[u][v] && dis[u]==dis[v]+1){  
  22.             cur[u]=v;  
  23.             aug=min(aug,res[u][v]);  
  24.             pre[v]=u;  
  25.             u=v;  
  26.             if(v==t){  
  27.                 maxflow+=aug;  
  28.                 for(u=pre[u];v!=s;v=u,u=pre[u]) res[u][v]-=aug,res[v][u]+=aug;  
  29.                 aug=INF;  
  30.             }  
  31.             goto loop;  
  32.         }  
  33.           
  34.         int mind=n;  
  35.         for(v=0;v<n;v++)  
  36.             if(res[u][v]&&(mind>dis[v])){  
  37.                 cur[u]=v;  
  38.                 mind=dis[v];  
  39.             }  
  40.               
  41.             if((--gap[dis[u]])==0) break;  
  42.               
  43.             gap[dis[u]=mind+1]++;  
  44.             u=pre[u];  
  45.     }  
  46.     return maxflow;  
  47. }  

 

sap+gap+邻接表

[cpp] view plaincopy
  1. typedef struct{  
  2.     int t,r,contrary,next;  
  3. }Edge;  
  4. Edge edge[MAXE];  
  5. int n,m,source,sink,edge_sum,maxflow;  
  6. int head[MAXV],dis[MAXV],cur[MAXV],gap[MAXV],pre[MAXV];  
  7.   
  8. void sap(){  
  9.     int u=pre[source]=source,tmp=INF,v,a;  
  10.     memset(dis,0,sizeof(dis));  
  11.     memset(gap,0,sizeof(gap));  
  12.   
  13.     for(v=0;v<=n;v++) cur[v]=head[v];  
  14.   
  15.     gap[source]=n;  
  16.     maxflow=0;  
  17.   
  18.     while(dis[source]<n){  
  19. loop:  
  20.         for(v=cur[u];v!=-1;v=edge[v].next){  
  21.             a=edge[v].t;  
  22.             if(dis[u]==dis[a]+1 && edge[v].r>0){  
  23.                 cur[u]=v;  
  24.                 tmp=min(tmp,edge[v].r);  
  25.                 pre[a]=u;  
  26.                 u=a;  
  27.                 if(u==sink){  
  28.                     while(u!=source){  
  29.                         u=pre[u];  
  30.                         edge[cur[u]].r-=tmp;  
  31.                         edge[cur[u]^1].r+=tmp;  
  32.                     }  
  33.                     maxflow+=tmp;  
  34.                     tmp=INF;  
  35.                 }  
  36.                 goto loop;  
  37.             }  
  38.         }  
  39.   
  40.         int mind=n;  
  41.         for(v=head[u];v!=-1;v=edge[v].next){  
  42.             a=edge[v].t;  
  43.             if(edge[v].r>0 && mind>dis[a]){  
  44.                 cur[u]=v;  
  45.                 mind=dis[a];  
  46.             }  
  47.         }  
  48.   
  49.         if((--gap[dis[u]])==0) break;  
  50.   
  51.         gap[dis[u]=mind+1]++;  
  52.         u=pre[u];  
  53.     }  
  54. }  


 

dinic算法(连续最短增广路算法)：
首先dinic也用到了分层的思想，但是它与最短增广路不同的是：
SAP在每个阶段执行完一次BFS增广后，要重新启动BFS从源点到汇点找一条增广路
Dinic算法，只要一次DFS过程就能找出多条增广路，进行增广
下面简单描述下Dinic算法的过程：
首先分层，源点的层次为第0层，而汇点的层次为第d[t]层。
         ........①
分层之后，进行深搜，深搜的时候也是按允许弧深搜(容量>流量，并且由v指向u的一条弧满足d[v]=d[u]+1),在搜索的过程中会记录下当前的

最小流量和当前节点剩余流量，这样在回溯的时候就可以不断的找多条增广路并进行更新，因为是按照允许弧进行寻找增广路，所以也会满

足找的增广路是最短的。
         ........②
当深搜完毕之后，再次进行分层，即进行第①步
         ........③
分析dinic的复杂度，在每一个阶段，DFS遍历时前进与后退的花费为O(m×n),因为最多进行n次DFS，所以在Dinic算法中找增广路的总复杂度

为O(m×n^2)

 

[cpp] view plaincopy
  1. #define MAXV 410  
  2. #define INF INT_MAX  
  3. #define min(a,b) (a>b?b:a)  
  4.   
  5. int res[MAXV][MAXV];        //残量  
  6. int dis[MAXV];              //表示多少层  
  7. int source,sink,n,maxflow;                  //s为源点,t为汇点  
  8.   
  9. int bfs(){  
  10.     int k;  
  11.     queue<int> q;  
  12.     memset(dis,-1,sizeof(dis));  
  13.     dis[sink]=0;  
  14.       
  15.     q.push(sink);  
  16.     while(!q.empty()){  
  17.         k=q.front();  
  18.         q.pop();  
  19.         for(int i=0;i<n;i++){  
  20.             if(dis[i]==-1 && res[i][k]){  
  21.                 dis[i] = dis[k] + 1;  
  22.                 q.push(i);  
  23.             }  
  24.         }  
  25.         if(k==source) return 1;  
  26.     }  
  27.     return 0;  
  28. }  
  29.   
  30. int dfs(int cur,int cp){  
  31.     if(cur==sink)   return cp;  
  32.       
  33.     int tmp=cp,t;  
  34.     for(int i=0;i<n && tmp;i++){  
  35.         if(dis[i]+1==dis[cur] && res[cur][i]){  
  36.             t=dfs(i,min(res[cur][i],tmp));  
  37.             res[cur][i]-=t;  
  38.             res[i][cur]+=t;  
  39.             tmp-=t;  
  40.         }  
  41.     }  
  42.     return cp-tmp;  
  43. }  
  44.   
  45. void dinic(){  
  46.     maxflow=0;  
  47.     while(bfs()) maxflow+=dfs(source,INF);  
  48. }  








邻接表：邻接表：邻接表：邻接表：邻接表：邻接表：


邻接表：

 

[cpp] view plaincopy
  1. typedef struct{  
  2.     int s,t,r,next;  
  3. }Edge;  
  4.   
  5. Edge edge[MAXE];  
  6.   
  7. int n,m,source,sink,edge_sum,maxflow;  
  8. int head[MAXV],dis[MAXV];  
  9.   
  10. int bfs(){  
  11.     int i,v,tmp;  
  12.     queue <int>q;  
  13.     memset(dis,0,sizeof(dis));  
  14.     dis[source]=1;  
  15.     q.push(source);  
  16.     while(!q.empty()){  
  17.         v=q.front();q.pop();  
  18.         for(i=head[v];i!=-1;i=edge[i].next){  
  19.             tmp=edge[i].t;  
  20.             if(!dis[tmp] && edge[i].r){  
  21.                 dis[tmp]=dis[v]+1;  
  22.                 if(tmp==sink) return 1;  
  23.                 q.push(tmp);  
  24.             }  
  25.         }  
  26.     }  
  27.     return 0;  
  28. }  
  29.   
  30. int dfs(int cur,int cp){  
  31.     if(cur==sink) return cp;  
  32.   
  33.     int tmp=0,i,a,t;  
  34.     for(i=head[cur];i!=-1 && tmp<cp;i=edge[i].next){  
  35.         a=edge[i].t;  
  36.         if(dis[a]==dis[cur]+1 && edge[i].r){  
  37.             t=dfs(a,min(edge[i].r,cp-tmp));  
  38.             edge[i].r-=t;  
  39.             edge[i^1].r+=t;         //反边减残量  
  40.             tmp+=t;  
  41.         }  
  42.     }  
  43.     if (!tmp) dis[cur]=-1;      //这里代表流已经没了，或者说此路不通  
  44.     return tmp;  
  45. }  
  46.   
  47. void dinic(){  
  48.     maxflow=0;  
  49.     while(bfs()) maxflow+=dfs(source,INF);  
  50. }  


 


相对来说，EK算法和dinic算法容易实现和调试，并且dinic算法的效率也很高，所以大多数人都选择了dinic算法，但是sap的gap优化其实效

率是大于dinic的，所以有的时候卡时间可以选择sap+gap优化


最大费用最大流：
最大流问题仅注意网络流的流通能力，没有考虑流通的费用。实际上费用因素是很重要的。例如在交通运输问题中，往往要求在完成运输任

务的前提下，寻求一个使总运输费用最省的运输方案，这就是最小费用流问题。如果只考虑单位货物的运输费用，那么这个问题就变成最短

路径问题，由此可见，最短路问题是最小费用流问题的基础。现已有一系列求最短路的成功方法。 最小费用流(或最小费用最大流)问题，可

以交替使用求解最大流和最短路两种方法，通过迭代得到解决。
一般讲费用看成是求最小路径的模型，在求最短路的时候限制一下条件就可以了。
MCMF(spfa)邻接矩阵：

[cpp] view plaincopy
  1. int source,sink,maxflow,mincost;  
  2. int res[MAXV][MAXV],cost[MAXV][MAXV];  
  3. int parent[MAXV],d[MAXV];  
  4.   
  5. void spfa(){  
  6.     queue <int>q;  
  7.     int i,v;  
  8.     bool vis[MAXV];  
  9.     memset(parent,-1,sizeof(parent));  
  10.     memset(vis,false,sizeof(vis));  
  11.   
  12.     for(i=source;i<=sink;i++) d[i]=INF;  
  13.     d[source]=0;  
  14.     q.push(source);  
  15.     vis[source]=true;  
  16.   
  17.     while(!q.empty()){  
  18.         v=q.front();q.pop();  
  19.         vis[v]=false;  
  20.   
  21.         for(i=0;i<=sink;i++){  
  22.             if(res[v][i] && d[v]+cost[v][i]<d[i]){  
  23.                 d[i]=d[v]+cost[v][i];  
  24.                 parent[i]=v;  
  25.                 if(!vis[i]){  
  26.                     vis[i]=true;  
  27.                     q.push(i);  
  28.                 }  
  29.             }  
  30.         }  
  31.     }  
  32. }  
  33.   
  34. void MCMF(){  
  35.     int v,minflow;  
  36.     maxflow=0;          //总的最大流  
  37.     while(1){  
  38.         spfa();  
  39.         if(parent[sink]==-1) break;         //搜不到最短路了就退出  
  40.   
  41.         minflow=INF;            //找出最短路径的最小增广流  
  42.         v=sink;  
  43.         while(parent[v]!=-1){  
  44.             minflow=min(minflow,res[parent[v]][v]);  
  45.             v=parent[v];  
  46.         }  
  47.   
  48.         v=sink;                 //对增广路进行流增广  
  49.         while(parent[v]!=-1){  
  50.             res[parent[v]][v]-=minflow;  
  51.             res[v][parent[v]]+=minflow;  
  52.             v=parent[v];  
  53.         }  
  54.         maxflow+=minflow;  
  55.         mincost+=d[sink]*minflow;           //总的代价  
  56.     }  
  57. }  


 

MCMF(spfa)邻接表：

 

[cpp] view plaincopy
  1. #define INF INT_MAX  
  2. #define min(a,b) (a>b?b:a)  
  3. #define MAXV 1100  
  4. #define MAXM 40100  
  5.   
  6. typedef struct{  
  7.     int s,t,next,w,r;  
  8. }Edge;  
  9.   
  10. Edge edge[MAXM];  
  11. int source,sink,n,m,mincost,edgesum;  
  12. int head[MAXV],d[MAXV],parent[MAXV];  
  13.   
  14. void addedge(int a,int b,int c,int r){      //无向边要求两次，一条无向边对应4条这样的边  
  15.     edge[edgesum].s=a;  
  16.     edge[edgesum].t=b;  
  17.     edge[edgesum].r=r;  
  18.     edge[edgesum].w=c;  
  19.     edge[edgesum].next=head[a];  
  20.     head[a]=edgesum++;  
  21.       
  22.     edge[edgesum].s=b;  
  23.     edge[edgesum].t=a;  
  24.     edge[edgesum].r=0;  
  25.     edge[edgesum].w=-c;  
  26.     edge[edgesum].next=head[b];  
  27.     head[b]=edgesum++;  
  28. }  
  29.   
  30. int spfa(){  
  31.     queue <int>q;  
  32.     int v,i,tmp;  
  33.     bool vis[MAXV];  
  34.       
  35.     for(i=0;i<=sink;i++) d[i]=INF;  
  36.     memset(vis,false,sizeof(vis));  
  37.     memset(parent,-1,sizeof(parent));  

  39.     q.push(source);  
  40.     vis[source]=true;  
  41.     d[source]=0;  
  42.     while(!q.empty()){  
  43.         v=q.front();q.pop();  
  44.         vis[v]=false;  
  45.           
  46.         for(i=head[v];i!=-1;i=edge[i].next){  
  47.             tmp=edge[i].t;  
  48.             if(edge[i].r && edge[i].w+d[v]<d[tmp]){  
  49.                 d[tmp]=edge[i].w+d[v];  
  50.                 parent[tmp]=i;  
  51.                 if(!vis[tmp]){  
  52.                     q.push(tmp);  
  53.                     vis[tmp]=true;  
  54.                 }  
  55.             }  
  56.         }  
  57.     }  
  58.     return 0;  
  59. }  
  60.   
  61. void MCMF(){  
  62.     int u,minflow;  
  63.     mincost=0;  
  64.     while(1){  
  65.         spfa();  
  66.         if(parent[sink]==-1) break;  
  67.   
  68.         minflow=INF;  
  69.         u=parent[sink];  
  70.             while(u!=-1){  
  71.             minflow=min(minflow,edge[u].r);  
  72.                     u=parent[edge[u].s];  
  73.             }  
  74.           
  75.         u=parent[sink];  
  76.             while(u!=-1){  
  77.             edge[u].r-=minflow;  
  78.             edge[u^1].r+=minflow;  
  79.                     u=parent[edge[u].s];  
  80.             }  
  81.             mincost+=d[sink]*minflow;  
  82.         maxflow+=minflow;  
  83.     }  
  84. }  
java怎样创建服务 java怎样创建服务
原创粉丝点击
热门IT博客
免费的linux服务器免费的linux服务器
php不支持mysqlphp不支持mysql
数字密码锁屏软件
300和dcs通讯编程实例
软件编程需要学什么
js 删除数组选取
产品展示网站php源码
python论坛推荐
数据仓库数据特点
在线视频直播间源码
js获取video播放时间
js 判断div是否显示
卓诗尼官方旗舰店淘宝
网站数据加密
淘宝手机怎么删除评价
python字符串截取函数
朝天鼻矫正方法知乎
安全炒股软件
网络规划设计师薪资
讲故事什么软件好
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 生血宝合剂 桔贝合剂 鱼腥草合剂 热炎宁合剂 石硫合剂 甘草合剂 泰坦合剂 能量合剂 小青龙合剂 双金连合剂 八正合剂 螯合剂 肺立咳合剂 合剂 咽舒合剂 产妇安合剂 四季抗病毒合剂 复方鱼腥草合剂 肺力咳合剂适于哪种咳嗽 宣肺止嗽合剂 复方甘草合剂 肺力咳合剂说明书 桔贝合剂小儿用量 恒古骨伤愈合剂 桔贝合剂说明书 厚朴排气合剂 生血宝合剂100ml多少钱一盒 小儿感冒宁合剂 石硫合剂熬制方法 复方鱼腥草合剂儿童用量 藿香正气合剂 生血宝合剂适合什么人喝 生血宝合剂孕妇能吃吗 复方大青叶合剂 君歧肠胃合剂多少钱一盒 君歧肠胃合剂 鱼腥草芩蓝合剂 山白消食合剂 参歧肠泰合剂 蚕蛾公补合剂 独活寄生合剂

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里