网络流常用算法

最新推荐文章于 2023-12-27 18:06:05 发布
最新推荐文章于 2023-12-27 18:06:05 发布
阅读量91 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/tangcong/archive/2012/07/07/2580734.html

1.sap

递归版。

View Code 
#include <iostream>
using namespace std;

#define MAXN 10000
struct Edge
{
  int v, next, val;
  Edge( ) { }
  Edge( int V, int N, int Val): v(V), next(N), val(Val) {}             
}edge[MAXN];

int head[MAXN],size, flow, visit, sum, N, M, ans;
int gap[MAXN], h[MAXN];

/*
sap算法核心:
1.dfs搜索增广路
2.标号  若存在v(i, j)， 则h[i] = h[j] + 1
3.gap优化 若出现断层。。则结束 
4.更新，正向更新，反向相减 
*/
 
void init( )
{
  for( int i = 0; i < MAXN; i++)
  {
      head[i] = -1;        
       
  }     
  size = 0;
     
}


void AddEdge( int u, int v, int val)
{
   edge[size] = Edge(v, head[u], val);
   head[u]  = size++;
   
   edge[size] = Edge(u, head[v], 0);
   head[v] = size++;
     
}


int dfs( int x, int flow = 0x7f7f7f7f)
{
   if( x == N )
   {
      return flow;    
   }
   int v, u, high = N, f, tf = 0;
   for( v = head[x]; v != -1; v = edge[v].next )
   {
      u = edge[v].v;
      if( edge[v].val > 0 )
      {
        if( h[x] == h[u] + 1 && (f = dfs(u, min(flow - tf, edge[v].val))))
        {
          edge[v].val -= f;
          edge[v^1].val += f;
          tf += f;
          if( h[1] >= N || tf == flow)
            return tf;       
        }
        high = min(high, h[u]);
      }   
        
   }
   if( tf  == 0 )
   {
      gap[h[x]]--;
      if( gap[h[x]] == 0 )
         h[1] = N;
      h[x] = high + 1; 
      gap[h[x]]++;     
   }
   return tf;    
}

void solve( )
{
   gap[0] = N;
   memset(h, 0, sizeof(h));
   sum = 0;
   while( h[1] < N )
      sum += dfs( 1 );
   printf("Case %d: %d\n",++ans, sum);  
}


int main( )
{
   int a, b, c, T;
   ans = 0;
   scanf("%d",&T);
   while( T-- )
   {
     scanf("%d%d",&N, &M);
     init( );
     for( int i = 1; i <= M; i++)
     {
       scanf("%d%d%d",&a, &b, &c);
       AddEdge(a, b, c);
     }
     solve( );
   } 
   return 0; 
}

 

2. sap非递归版

View Code 
#include <iostream>
#include <queue>
using namespace std;

#define MAXN 10000
struct  Edge
{
 int v, next, val;
 Edge( ) { }
 Edge( int V, int N, int Val): v(V), next(N), val(Val) { }
}edge[MAXN];


int head[MAXN], cur[MAXN], gap[MAXN], h[MAXN], path[MAXN], size, N, M, ans;
queue<int>q;

void init( )
{
  for( int i = 0; i < MAXN; i++)
     head[i] = -1;
  size = 0;     
     
}

void AddEdge( int u, int v, int val)
{
  edge[size] = Edge(v, head[u],val);
  head[u] = size++;
  
  edge[size] = Edge(u, head[v], 0);
  head[v] = size++;     
     
}

void bfs(  )
{
   q.push( N );
   while( !q.empty() )
   {
      int x = q.front();
      q.pop( );
      for( int u = head[x]; u != -1; u = edge[u].next)
      {
           int v = edge[u].v;
           if( h[v] == 0 && edge[u^1].val >  0)
           {   
               gap[0]--;
               h[v] = h[u] + 1;
               gap[h[v]]++;
               q.push( v );
           } 
      }
          
   }  
     
}


void sap( )
{
   memset(h, 0, sizeof(h));
   memset(gap, 0, sizeof(gap));
   for( int i = 0; i < MAXN; i++)
   {
       cur[i] = head[i];
       path[i] = 0;
   }
   gap[0] = N;
   int u = 1, v, flow = 0x7f7f7f7f, high, sum = 0;
   path[u] = u = 1;
   while( h[1] < N )
   {
     int f = 0;
     for( int &x = cur[u]; x != -1; x = edge[x].next )
     {
        if( edge[x].val > 0 )
        {
             int v = edge[x].v;
             int w = edge[x].val;
             if( h[u] == h[v] + 1 )
             {
                 
                 path[v] = u;
                 u = v;
                 flow = min(flow,  edge[x].val);
                 f = 1;
                 if( v == N )
                 {   
                     sum += flow;
                     for( u = path[v] ; v != 1; v = u, u = path[u])
                     {
                          edge[cur[u]].val -= flow;
                          edge[cur[u]^1].val += flow;
                     }     
                     flow = 0x7f7f7f7f;              
                 }
                 break;
              }      
                     
        }
     }
     if( f )
         continue;
     high = N;
     for( int t = head[u]; t != -1; t = edge[t].next )
     {
         int w = edge[t].val;
         int v = edge[t].v;
         if( w > 0 )
         {
            if( h[v] < high )
            {
              high = h[v];
              cur[u] = t;
            }    
         }
     }
     gap[h[u]]--;
     if( gap[h[u]] == 0 )
         h[1] = N;
     h[u] = high + 1;
     gap[h[u]]++;
     u = path[u];       
   }     
   printf("Case %d: %d\n",ans++,sum);
}

int main( )
{
  int a,b,c,T;
  scanf("%d", &T);
  ans = 1;
  while(T--)
  {
     scanf("%d%d", &N, &M);
     init( );
     for( int i = 0; i < M; i++)
     {
        scanf("%d%d%d",&a, &b,&c);
        AddEdge(a,b,c);       
     }
     sap();
  }
  return 0;
}

 

3.dinic非递归版本

View Code 
#include <iostream>
#include <queue>
using namespace std;

#define MAXN 10610
struct Edge
{
  int v, next, val;
  Edge( ) { }
  Edge(int V,int N, int Val): v(V), next(N), val(Val) { }
}edge[MAXN];

queue<int>q;
int head[MAXN], h[MAXN], size, N, M, ans, cur[MAXN];

int Q[106000];

void init( )
{
  for( int i = 0; i < MAXN; i++)
     head[i] = -1;
  size = 0;     
}

void AddEdge( int u, int v, int val)
{
   edge[size] = Edge(v, head[u], val);
   head[u] = size++;
   
   edge[size] = Edge(u, head[v], 0);
   head[v] = size++;    
}

int bfs( )
{ 
  memset( h, -1, sizeof(h));
  q.push( 1 );
  h[1] = 0;
  while( !q.empty())
  {
     int x = q.front();
     q.pop( );
     for( int e = head[x];  e != -1; e = edge[e].next)
     {
         int w = edge[e].val;
         int v = edge[e].v;
         if( w >  0 && h[v] == -1)
         {
            h[v] = h[x] + 1;    
            q.push( v );
         }     
          
     }
         
  }
  return h[N] != -1;    
}


int dfs( )
{
   int e, u, v, w, p, i, sum = 0, f = 0;
   for( int i = 0; i <= N + 100; i++)
        cur[i] = head[i];
   p = 1;
   Q[p] = 1;
   while( p )
   {      
      int x = Q[p];
      if( x == N )
      {
         int flow = 0x7fffffff;
         for( i = 1; i < p; i++)
         {
            x = Q[i];
            e = cur[x];
            if( edge[e].val < flow )
                flow = edge[e].val;
         }
         int mid;
         for( i = 1; i < p; i++)
         {
            x = Q[i];
            e = cur[x];
            if( edge[e].val == flow )
               mid = i;
            edge[e].val -= flow;
            edge[e^1].val += flow;        
         }
         p = mid;
         sum += flow;
         continue;   
      } 
      for(e = cur[x]; e != -1; e = edge[e].next)
      {
        v = edge[e].v;
        w = edge[e].val;
        if( h[v] == h[x] + 1 && w >  0 )
        {
           Q[++p] =  v;   
           break;     
        }
      }
      cur[x] = e;
      if( e == -1 ) { p--;  cur[Q[p]] = edge[cur[Q[p]]].next; }  
   }
   return sum;
}


void solve( )
{
   int sum = 0;
   while( bfs( ) )
      sum += dfs( );
   printf("Case %d: %d\n",ans++,sum);
}

int main( )
{
  int a, b, c, T;
  scanf("%d",&T);
  ans = 1;
  while(T--)
  {
     scanf("%d%d",&N, &M);
     init( );
     for( int i = 1; i <= M; i++)
     {
       scanf("%d%d%d",&a, &b, &c);
       AddEdge(a, b, c);
     }
     solve( );          
  }  
  return 0;   
}

 

4.dinic递归版

View Code　 
#include <iostream>
#include <queue>
using namespace std;

#define MAXN 1010
struct Edge
{
  int v, next, val;
  Edge( ) { }
  Edge(int V,int N, int Val): v(V), next(N), val(Val) { }
}edge[MAXN];
queue<int>q;

int head[MAXN], h[MAXN], size, N, M, flow, visit, ans;


void init( )
{
  for( int i = 0; i < MAXN; i++)
     head[i] = -1;
  size = 0;     
     
     
}

void AddEdge( int u, int v, int val)
{
   edge[size] = Edge(v, head[u], val);
   head[u] = size++;
   
   edge[size] = Edge(u, head[v], 0);
   head[v] = size++;    
}

int bfs( )
{ 
  memset( h, -1, sizeof(h));
  q.push( N );
  h[N] = 0;
  while( !q.empty())
  {
     int x = q.front();
     q.pop( );
     for( int e = head[x];  e != -1; e = edge[e].next)
     {
         int w = edge[e^1].val;
         int v = edge[e].v;
         if( w >  0 && h[v] == -1)
         { 
            //printf("x = %d v = %d w = %d\n", x, v, w);
            h[v] = h[x] + 1;    
            q.push( v );
         }     
          
     }
         
  }
  return h[1] != -1;    
}


int dfs(int x, int flow = 0x7f7f7f7f)
{
   if( x == N  )
   {
      return flow;
   }
   int e, tf = 0, f;
   for(e = head[x]; e != -1; e = edge[e].next)
   {
       int v = edge[e].v;
       int w = edge[e].val;
       if( h[x] == h[v] + 1 && w >  0 && (f = dfs(v, min(flow - tf, w))) )
       {
             
           edge[e].val -= f;   
           edge[e^1].val += f; 
           tf += f;
       }     
        
   } 
   if( tf == 0)
       h[x] = -1;
   return tf;
}


void solve( )
{
   int sum = 0;
   while( bfs( ) )
      sum += dfs(1);
   printf("Case %d: %d\n",ans++,sum);
}

int main( )
{
  int a, b, c, T;
  scanf("%d",&T);
  ans = 1;
  while(T--)
  {
     scanf("%d%d",&N, &M);
     init( );
     for( int i = 1; i <= M; i++)
     {
       scanf("%d%d%d",&a, &b, &c);
       AddEdge(a, b, c);
     }
     solve( );          
  }  
  return 0;   
}

转载于:https://www.cnblogs.com/tangcong/archive/2012/07/07/2580734.html

最大流与最小割问题：网络流算法解析
一键难忘的博客
08-04 4274
最大流问题是指在一个有向图中，从源点到汇点传输的最大流量。图中的每条边都有一个容量，表示其最大能通过的流量。我们的目标是找到从源点到汇点的路径，使得流量最大化。给定一个有向图 ( G = (V, E) )，其中 ( V ) 是顶点集合，( E ) 是边集合。每条边 ( (u, v) ) 具有一个容量 ( c(u, v) )。源点 ( s ) 和汇点 ( t ) 是两个特殊的顶点。我们的目标是找到从 ( s ) 到 ( t ) 的最大流量。
【人人都要学算法】网络流算法远比你想的要好玩
远航 | FIBOS.io
11-17 3879
这个问题的由来是想起来明天将会有国足世预赛的比赛，于是今天去看了看国足目前在小组中的积分。在积分榜中，我们可以看到与中国同组的马尔代夫和不丹都已经没有了出线的机会，即使他们剩余的比赛全胜也不可能出线了。我在想，有没有一个通用的方法，可以算出各支队还有没有出现的可能。 ====现在我们来回归正题： 网络流(network-flows)是一种类比水流的解决问题方法，与线性规划密切相关。网络流的理论和
网络流简单总结
Yu Gi Oh!
02-14 616
网络流 一.最大流 1.网络流 1. 网络 网络 G=(V,E,C,s,t) 是一个连通的有向图，且满足如下性质： 对于任意一个时刻，设f(u,v)实际流量，则整个图G的流网络满足以下性质： 容量限制：对任意u,v∈V，f(u,v)≤c(u,v)。 反对称性：对任意u,v∈V，f(u,v)=-f(v,u)。从u到v的流量一定是从 v到u的流量的相反值。 流守恒性：对任...
网络分析的核心算法：从基础到高级
最新发布
AI天才研究院
12-27 1782
1.背景介绍 网络分析是一种广泛应用于社交网络、信息传播、物联网等领域的数据挖掘技术。它主要涉及到对网络结构的分析、节点特征的提取以及信息传播的模拟等方面。在这篇文章中，我们将从基础到高级，深入探讨网络分析的核心算法。 1.1 社交网络的基本概念 在进入具体的算法之前，我们需要了解一些社交网络的基本概念。 1.1.1 节点和边 在社交网络中，节点(node)表示网络中的实体，如人、组织等...
网络流算法（Network Flow）
BigFatSheep的博客
12-11 2万+
网络流概览1.网络流（Network Flow）概念网络流起源于对于交通网络的分析，举一个非正式的例子，网络流算法的目的就是找到带权有向图中从源点到汇点的traffic的大小。我们的目标是在多项式时间内解决问题。我们一般要求的是最大流，如果把源点比作工厂的话，问题就是求从工厂最大可以发出多少货物，是不至于超过道路的容量限制，也就是——最大流。2.网络流的一些定义流量网络：给一个有向图G=(V,E)G
常见限流算法和Guava RateLimiter实现
热门推荐
张彦峰的博客
01-17 85万+
本文探讨了限流（Rate Limiting）的基本原理及常见算法，包括令牌桶算法、漏桶算法和固定窗口算法，并分析了它们在分布式系统中的应用。通过具体示例介绍了Guava的RateLimiter组件的使用，阐述了如何在高并发场景下实现流量控制。限流策略不仅能保障系统稳定性，还能有效防止过载和滥用。掌握合适的限流算法，有助于提升系统的性能和可用性，确保在流量波动时维持服务质量。
最大网络流ISAP算法
09-01
最大网络流问题是一个在图论和运筹学中常见的优化问题，主要研究在网络图中从一个源节点到一个汇点能传输的最大流量。ISAP（Iterative Scaling Augmenting Path，迭代标度增广路径）算法是解决这个问题的一种经典...
网络流算法PPT学习教案.pptx
10-01
网络流算法是图论中的一个核心概念，广泛应用于计算机科学、运筹学、经济学和工程等领域，主要用于解决网络中资源的最优分配问题。在PPT学习教案中，通常会涵盖以下知识点： 1. **基本概念**：网络流问题通常由一个...
algorithms-graphtheory-networkflow:python中的网络流算法实现
04-06
在Python中，有几种常见的网络流算法实现，包括Ford-Fulkerson方法和Edmonds-Karp算法。Ford-Fulkerson算法是基于增广路径的概念，它不断地寻找从源到汇的增广路径（即当前可增加流量的路径），直到无法找到为止。而...
最大流（网络流基础概念+三个算法）
x_y_q_的博客
07-22 3万+
下面是由一道题引发的一系列故事。。。 题目链接 http://poj.org/problem?id=1273 Drainage Ditches Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 68920 Accepted: 26683 Descri
【网络流】
leolin_的专栏
01-15 2万+
放假以来把网络流看来几篇，今天终于有点感觉，网上很多资料，我认为网络流最难理解的是加反向边，这个东西纠结了很久，网上搜到一个blog才领悟到一句真理：“反向边的作用就是给程序一个可以后悔的机会”，详细请看下面的文章，由于自己对网络流还是vegetables bird，所以只好转一下人家写的好文章。 网络流(Network Flow)      将每条有向
浅谈网络流的基本算法
weixin_34185364的博客
10-20 383
　　　　网络流的基本算法——绝恋love枫 引言 　　过去听起来高深莫测的网络流算法，现在已飞入寻常百姓家了，对于每一个OIER，网络流是一个神圣的东西（个人见解），但神圣的同时，它并不是那样抽象，最形象的模型就是水流，从长江源点无限的向外流水，而大海（汇点）则在不断地‘喝水’，当然，你也可以不把它想成水，或者是其他一切可以流动的东西。而事实上，有些东西的流动比较流畅，而某些东西可能相对而...
最大网络流问题
weixin_34001430的博客
05-27 522
之前参加阿里巴巴的笔试碰到一最大网络流的题目。因为之前没有看过这类算法，所以还是自然没做出。今天抽空看了看。了解了下基本概念和求解流程。这里简单总结下。 主要内容来自百度文库某ppt。在每幅图片的下面我会给出一些说明性文字。 本图示最大流的一个实例。由此，可以引出最大流的一些基本的定义和概念 可以这样看，图就是一种管道，管道有最大通过流量的限制，图中边的权值就是所谓的“容量”。同时，...
【数据结构和算法】常用基本算法汇总4 网络流
笑扬轩逸的博客
10-29 1223
A_Comme_Amour 的文章[网络流]学习笔记：一次理解网络流！ 基本概念 网络流用于解决流量问题 网络流:所有弧上流量的集合f={f(u,v)},称为该容量网络的一个网络流. 定义：带权的有向图G=(V,E)，满足以下条件，则称为网络流图(flow network)： 仅有一个入度为0的顶点s，称s为源点 仅有一个出度为0的顶点t，称t为汇点 每条边的权值都为非负数，称为该边的...
常见分类算法
xxx
05-17 2万+
常见分类算法 朴素贝叶斯网络、贝叶斯信念网络、随机森林、k-最近邻分类 云聚类算法引擎 k-Means、Canopy、Fuzzy K-Means、Mean Shift 云关联规则算法引起 FP-Growth关联规则 云智能推荐算法引擎 基于内存的协同过滤、基于模型的协同过滤...
网络流及其算法
Evan_song1234的博客
02-08 1990
网络流 源点 流量为 inf⁡\infinf 的一个点，网络流起点，一般用 sss 表示。 汇点 接收流量的一个点，网络流终点。 弧 一条有向边。 弧的流量 实际通过这条弧的流量。 弧的容量 指的是一条弧的最大流量。 网络流 所有弧上流量的集合。 增广路径 从源点 sss 到汇点 ttt 的一条可以有流量的路径。 可行弧 也成允许弧，当 (i,j)(i, j)(i,j) 为一个可行弧时，di=dj+1d_i=d_j+1di​=dj​+1，ddd 为当前点 bfsbfsbfs 时的深度 可行流 一张图能够达成
计算机网络中的一些常见算法
u012516914的专栏
11-04 3579
网络地址和主机地址的算法： 把子网掩码转换为2进制，然后与IP相与，就能得到网络地址。主机地址就是除去网络地址的部分。 例如：IP为192.168.26.100 子网掩码为255.255.255.0 它的网络地址就是192.168.26.0 主机地址就是0.0.0.100 例如：把网络117.15.32.0/23划分为117.15.32.0/27，得到的子网是（）个，每个子网中可使用的主机地址
网络流的最大流入门（从普通算法到dinic优化）
stevensonson的博客
01-26 1万+
网络流(network-flows)是一种类比水流的解决问题方法，与线性规划密切相关。网络流的理论和应用在不断发展。而我们今天要讲的就是网络流里的一种常见问题——最大流问题。 最大流问题(maximum flow problem)，一种组合最优化问题，就是要讨论如何充分利用装置的能力，使得运输的流量最大，以取得最好的效果。求最大流的标号算法最早由福特和福克逊与与1956年提出，20世纪50年代福
优化的预流推进算法：网络流算法深度解析
预流推进算法是一种常用的求解网络流问题的迭代方法，但在原始形式下，其效率较低，尤其是在非饱和推进阶段。为了提高效率，relabel-to-front算法应运而生。这种算法通过对关键操作的排序，减少了非饱和推进和重标号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值