您的位置:首页 > 理论基础 > 计算机网络

网络流小结 - hdu 1532

chen_ze_hua 2016-03-24 18:53 81 查看
网络流问题在已经知道每条边的容量以及流量的情况下,求出从起点到终点可以运送的最大流量。

这里面需要注意的有:容量限制,斜对称性和流量平衡的3个条件。

容量限制即保证每个边流过的流量小于每个边的容量 ,即f(u,v) < c(u,v);

斜对称性即为:f(u,v) = -f(v,u);

流量平衡即为:除了起点和终点外每个点都需要流进的流量等于流出的流量,同时起点流出的流量要等于终点流入的流量。

我们在解决问题的时候,用到的增广路算法就是需要不断地增加流量,知道无法增加流量为止。

同时需要构建一个残余网络图,这在下面的代码中我会介绍。

增光路算法基于一个事实:残余网络任何一条从s到t的有向道路都对应原图中的一条增广路———只要求出该道路中所有所有残量的最小值d,

把对应的所有边的流量增加d即可,这个过程称为增广。

增广前的流量满足我所介绍的3个条件,很显然我们增广后的流量仍然满足以上的3个条件。

这里我介绍一下增广路定理:如果残余网络不存在增广路,则当前流就是最大流。

因为要找任意路径,做一简单的方法就是dfs,但是有时候会很慢。对于杭电1532 Drainage Ditches这道模板题我首先给出dfs方法

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 205;
const int INF = 0x3f3f3f3f;

struct Node
{
int to; //终点
int cap; //容量
int rev; //反向边的编号
};

vector <Node> v
;
bool used
;

void add_Node(int from,int to,int cap)
{
v[from].push_back((Node){to,cap,v[to].size()});
v[to].push_back((Node){from,0,v[from].size()-1}); //因为已经放进去了所以要减一。
}

int dfs(int s,int t,int f)
{
if(s == t) return f;
used[s] = true;
for(int i = 0; i < v[s].size(); i++)
{
Node& temp = v[s][i];
if(!used[temp.to] && temp.cap > 0)
{
int d = dfs(temp.to,t,min(f,temp.cap));  //这里就是前面我所说的找出增广路上所有残量的最小值
if(d > 0)
{
temp.cap -= d;
v[temp.to][temp.rev].cap += d; //要满足上面的3个原理,因为需要对于已经找到的增广路上的边的最大流量进行调整
return d;
}
}
}
return 0; // 这一定不能省略,因为有可能找不到增广路,这时候就要返回0了。
}

int max_flow(int s,int t)
{
int flow = 0;
while(1)
{
memset(used,false,sizeof(used));
int f = dfs(s,t,INF);
if(f == 0)       //如果找不到增广路那么当前流就是最大流,这时就可以得到结果了。
return flow;
flow += f;
}
}

int main()
{
int n,m;
while(scanf("%d%d",&n,&m) != EOF)
{
memset(v,0,sizeof(v));
for(int i = 0; i < n; i++)
{
int from,to,cap;
scanf("%d%d%d",&from,&to,&cap);
add_Node(from,to,cap);
}
printf("%d\n",max_flow(1,m));
}
return 0;
}

还有一种方法就是bfs方法,这个算法可以对付一些不是很刁钻的网络流题目,这就是Edmonds-Karp算法,这里我同样以刚才的题目贴出bfs算法。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int maxn = 205;
const int INF = 0x3f3f3f3f;

struct Edge
{
int from,to,cap,flow;
Edge(int u, int v, int c, int f):from(u),to(v),cap(c),flow(f) {}
};

struct EK
{

int n,m;
vector <Edge> edges;
vector <int> G[maxn];
bool done[maxn];
int a[maxn];
int p[maxn];

void init(int n)
{
this->n = n;
for(int i = 0; i <= n; i++)
G[i].clear();
edges.clear();
}

void AddEdge(int from, int to, int cap)
{
edges.push_back(Edge(from,to,cap,0));
edges.push_back(Edge(from,to,0,0)); //·´Ïò»¡
m = edges.size();
G[from].push_back(m-2);
G[to].push_back(m-1);
}

int Maxflow(int s,int t)
{
int flow = 0;
for(;;)
{
memset(a,0,sizeof(a));
queue <int> Q;
Q.push(s);
a[s] = INF;
while(!Q.empty())
{
int x = Q.front(); Q.pop();
for(int i = 0; i < G[x].size(); i++)
{
Edge& e = edges[G[x][i]];
if(!a[e.to] && e.cap > e.flow)
{
p[e.to] = G[x][i];  //p数组用来存储增广路径。
a[e.to] = min(a[x],e.cap - e.flow);
Q.push(e.to);
}
}
if(a[t]) break;
}
if(!a[t]) break;
for(int u = t; u != s; u = edges[p[u]].from)
{
edges[p[u]].flow += a[t];     //通过异或运算得到反向边。
edges[p[u]^1].flow -= a[t];
}
flow += a[t];
}
return flow;
}

}result;

int main()
{
int m,n;
while(scanf("%d%d",&m,&n) != EOF)
{
result.init(n);
int u,v,cap;
for(int i = 0; i < m; i++)
{
scanf("%d%d%d",&u,&v,&cap);
result.AddEdge(u,v,cap);
}
printf("%d\n",result.Maxflow(1,n));
}
return 0;
}
标签: