网络流总结(二)

这些天学习网络流,总结了一下用到的主要算法,主要从下面几个方面来介绍

一、常见的几种算法

二、这些算法的复杂度

三、这些算法适合处理的问题

四、算法模板

FF方法(Ford_Fulkerson):

所有增广路径问题都是以Ford_Fulkerson方法为基础,之所以称为方法而不是算法,因为它提供的是一种思想。

Ford_Fulkerson(s,t)
	f = 0,对自定义流f进行初始化
	while 存在增广路径p 
		do 沿p对流f进行增广 //f += MaxFlow,MaxFlow为增广路径中最大流
	return p; //p即为整个图中最大流
我原来这个方法一直没有得到很好的理解,汗,现在才明白为什么叫增广路径,f是自己定义的一个流,原来图中存在容量c(i,j),在不超过c(i,j)的情况下尽情对f流进行增光,这样得到的f即为最大流。残留容量cf(i, j) = c(i, j) - f(i, j),网中所有cf(i, j) > 0 的边组成一个残留网络,每次对f进行一次增广,则cf(i, j) -= flow; cf(j, i) += flow;对反向边进行操作也是后面才了解,是为了给后面查找增广路径时候提供更多的选择,如果这个点不通了,则返回到上一个节点继续查找。这样最后残留网络中反向边流量cf(j, i) = f(i, j)。增广路径即s 到 t的一条路径。
沿增广路径进行增广的操作一般都是相同的,主要算法不同体现在对增广路径的寻找过程中。

Sap算法(Shortest Augmenting Path):

这是一类算法,每次寻找最短最广路径进行增广,后面的DK,Dinic算法都是基于此

Sap()
	ans = 0
	while 寻找增广路径
		do 存在一条最短增广路径p
		flow = min(cf(i, j) [i,j] ∈ E)
		ans += flow
		沿p进行增广 //正反两步
	return ans;

EK算法(Edmonds_Karp):

BFS寻找最短最广路径,最简单的一种寻找最短最广路径方法,算法复杂度为O(V*E^2),因为BFS寻找最短路径需要搜索完所有小于最短距离的边才能找到终点,所以算法复杂度比较高。

算法模板:

int path[nMax];
int queue[nMax];
int flow[nMax];
int s, t;
ek_Bfs()//算法复杂度O(E)
{
	int front, rear;
	front = rear = 0;
	queue[rear ++] = s;
	flow[s] = INF;
	while(front < rear)
	{
		int u = queue[front ++];
		if(u == t) break;
		for(int v = 0; v < n; ++ v)//其实就是搜索临边的意思
		{
			if(path[v] == -1 && map[u][v])
			{
				flow[v] = min(flow[u], map[u][v]);
				path[v] = u;
				queue[rear ++] = v;
			}
		}
	}
	if(path[t] == -1) return 0;
	else return flow[t];
}
ek_Flow()//算法复杂度O(V*E)
{
	int MaxFlow = 0;
	while((flow = ek_Bfs())
	{
		MaxFlow += flow;
		int cur = t;
		while(cur != s)
		{
			int pre = path[cur];
			map[pre][cur] -= flow;
			map[cur][pre] += flow;
			cur = pre;
		}
	}
	return MaxFlow;
}

Dinic算法:

算法思路:BFS寻找终点太慢,DFS又无法保证搜索到最短路径,结合这两种算法的优势,利用构造分层网络的算法来寻找最短路径,这个算法又称为阻塞流算法。
首先从s点处进行bfs搜索,dis[s] = 0,然后层次数依次增加,如果搜索到t,则结束。dfs进行搜索,逐层搜索,进行d[v] == d[u] + 1判断,任意一条路径即为最短路径。

建立层次图最大的作用就是规范DFS搜索,使尽可能向终点进行搜索。
Dinic 算法的另一个优化之处:找一条增广路径同时可以找到多条,类似增广路径树。如果cur顶点的总残余流量不为零,这样我们就不必要从起点再次开始寻找增广路,而是从cur顶点出发直接开始,这样就会减少了重复计算,提高效率。

时间复杂度:O(V^2*E)

模板:

struct Adj
{
	int v, w;
	int next;
}adj[mMax];//总边数
int head[nMax];
int cnt;
int dis[nMax];

int bfs(int s, int d)
{
	queue<int> que;
	que.push(s);
	memset(dis, -1, sizeof(dis));
	dis[s] = 0;
	int i;
	while(!que.empty())
	{
		int u = que.front();
		que.pop();
		for(i = head[u]; i != -1; i = adj[i].next)
		{
			int v = adj[i].v;
			if(adj[i].w && dis[v] == -1)
			{
				dis[v] = dis[u] + 1;
				que.push(v);
			}
		}
	}
	return dis[d];
}

int min(int a, int b)
{
	return a < b ? a : b;
}

int dfs(int s, int d, int cost)
{
	if(s == d) return cost;
	int t, ans = 0;
	int i;
	for(i = head[s]; i != -1; i = adj[i].next)
	{
		int v = adj[i].v;
		if(dis[v] == dis[s] + 1 && adj[i].w && (t = dfs(v, d, min(adj[i].w, cost))) != -1)
			//①原来这里漏写了adj[i].w != 0,结果超时
		{
			adj[i].w -= t;
			adj[i ^ 1].w += t;//③
			cost -= t;
			ans += t;
			if(!cost) break;
		}
	}
	return ans;
}

int dinic(int s, int d)//s:源点,d:汇点
{
	int ans = 0;
	while(bfs(s, d) != -1)
	{
		ans += dfs(s, d, INF);
	}
	return ans;
}

ISAP算法(sap优化算法):

算法思路:Dinic算法效率已经很高,然而算法的优化时无尽头的,Dinic算法需要多次计算层次图,增加了复杂度,是不是可以不多次计算层次图呢?答案是肯定的,这就是ISAP算法。
ISAP计算的是反向图的层次图,作用与原图的层次图一样。计算反向图的层次图是便于重新给顶点标号,即计算层次图,具体做法:在查找<u,v>的时候,MinDis = min(dis[v]),这样查找玩所有与顶点u相关的边之后,dis[u] = dis[v] + 1,从而得到新的层次图。在刚开始寻找的时候,我们也不需要计算层次图,对所有dis[]都赋值为0即可,对效率没有多大影响。
另外ISAP算法的另一个优化在于:如果层次图出现断层,则直接结束。

时间复杂度:O(V^2*E)

模板:

struct Adj
{
	int v, w;
	int next;
}adj[mMax];
int head[nMax];
int cnt;
int num[nMax];//每一层顶点的个数,便于判断层次图中是否出现断层
int dis[nMax];
int NN;//总顶点数


int min(int a, int b)
{
	return a < b ? a : b;
}

int dfs(int u, int s, int d, int cost)
{
	if(u == d) return cost;
	int i;
	int ans = 0;
	int _min = NN;
	for(i = head[u]; i != -1; i = adj[i].next)
	{
		int v = adj[i].v;
		if(adj[i].w)
		{
			if(dis[v] + 1 == dis[u])
			{
				int t = dfs(v, s, d, min(adj[i].w, cost));
				adj[i].w -= t;
				adj[i ^ 1].w += t;
				cost -= t;
				ans += t;
				if(dis[s] == NN) return ans;
				if(!cost) break;
			}
			if(_min > dis[v])
				_min = dis[v];
		}
	}
	if(!ans)
	{
		if(-- num[dis[u]] == 0) dis[s] = NN;
		dis[u] = _min + 1;
		++ num[dis[u]];
	}
	return ans;
}

int isap(int s, int d)
{
	memset(dis, 0, sizeof(dis));
	memset(num, 0, sizeof(num));
	num[0] = NN;
	int ans = 0;
	while(dis[s] < NN)//dis[s] == NV其实是你自己定义的一个终止条件,你也可以使用flag标记表示出现断层
		ans += dfs(s, s, d, INF);
	return ans;
}

匈牙利算法:

匈牙利算法,主要处理二分图最大匹配问题, 算法复杂度为O(V^3)
算法模板:
int link[nMax];
int useif[nMax];
int n, m;//A、B集合分别对应的顶点数

int getPath(int x)//寻找匹配边,算法复杂度O(m^2),即O(V^2)
{
	for(int i = 0; i < m; ++ i)
	{
		if(!useif[i] && map[x][i])
		{
			useif[i] = 1;
			if(link[i] == -1 && getPath(link[i]))//如果点i被匹配,检查点link[i]是否存在另外可匹配边
			{
				link[i] = x;
				return 1;
			}
		}
	}
	return 0;
}

int getNum()//返回最大匹配数,算法复杂度O(n),即O(V)
{
	int num = 0;
	memset(link, -1, sizeof(link));
	for(int i = 0; i < n; ++ i)
	{
		memset(useif, 0, sizeof(useif));
		num += getPath(i);
	}
	return num;
}

以上内容只是我的理解,这两篇博文总结的很不错,推荐一下!

http://www.cnblogs.com/longdouhzt/archive/2012/05/20/2510753.html

http://www.cnblogs.com/longdouhzt/archive/2012/05/20/2510743.html

图论继续学习:

http://starfall512.com/?p=272#comment-152


你可能感兴趣的:(网络流总结(二))