最小费用最大流问题

最小费用最大流就是在原来求最大流的基础上，假设每条边还有一个单位流量所需要的费用，因为最小费用的出现，原本的平行边变得有意义，并且允许反向增广，基本上就是将原本BFS改为进行一次BellmanFord算法寻找最短路径，只要初始流是该流量下的最小费用可行流，每次增广后的新流都是新流量下的最小费用流。下面POJ2135的题解：

题意：

从起点出发，走到终点再回到起点，每条边都对应一个时间，求所需的最短时间。

要点：

这题乍一看很像最短路径，但其实是一个最小费用最大流，可以等效为从起点到终点两次，这两次走过的边没有交集，所以把每条边对应的容量改为1，这样确保只能走一次，再加入一个超级源和一个超级汇，它们对应的容量为2。

15981228

Seasonal

2135

Accepted

1496K

172MS

C++

1899B

2016-08-18 18:30:13

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int N = 1050;
const int inf = 0x3f3f3f3f;//这个值要够大，否则会WA
struct Edge
{
	int from, to, flow, cap, cost;
};
bool vis[N];
int p[N], a[N], d[N];
vector<int> g[N];//邻接表，G[i][j]表示结点i的第j条边在edges数组中存储的下标
vector<Edge> edges;

void init(int n)
{
	for (int i = 0; i <= n; i++)
		g[i].clear();
	edges.clear();
}
void addedge(int from, int to, int cap, int cost)
{
	Edge temp1 = { from,to,0,cap,cost };
	Edge temp2 = { to,from,0,0,-cost };//允许反向增广
	edges.push_back(temp1);
	edges.push_back(temp2);
	int len = edges.size();
	g[from].push_back(len - 2);
	g[to].push_back(len - 1);
}
bool bellmanford(int s, int t,int &flow,int &cost)
{
	for (int i = 0; i < N; i++)
		d[i] = inf;//这里一开始用memset结果出错，调试了半天才找出来
	d[s] = 0;
	memset(vis,false, sizeof(vis));	
	memset(p, -1, sizeof(p));
	p[s] = -1;
	a[s] = inf;
	queue<int> que;
	que.push(s);
	vis[s] = true;
	while (!que.empty())
	{
		int u = que.front();
		que.pop();
		vis[u] = false;
		for (int i = 0; i < g[u].size(); i++)
		{
			Edge& e = edges[g[u][i]];
			if (e.cap > e.flow&&d[e.to] > d[u] + e.cost)//进行松弛，寻找最短路径也就是最小费用
			{
				d[e.to] = d[u] + e.cost;
				p[e.to] = g[u][i];
				a[e.to] = min(a[u], e.cap - e.flow);
				if (!vis[e.to])
				{
					que.push(e.to);
					vis[e.to] = true;
				}
			}
 		}
	}
	if (d[t] == inf)
		return false;
	flow += a[t];
	cost += d[t] * a[t];
	for (int i = t; i != s; i = edges[p[i]].from)
	{
		edges[p[i]].flow += a[t];
		edges[p[i]^1].flow -= a[t];
	}
	return true;
}
int mincost(int s, int t)
{
	int flow = 0, cost = 0;
	while (bellmanford(s, t, flow, cost))
		continue;
	return cost;
}

int main()
{
	int n,m;
	while (cin >> n >> m)
	{
		init(n+1);
		int u, v, w;
		for (int i = 0; i < m; i++)
		{
			cin >> u >> v >> w;
			addedge(u, v, 1, w);
			addedge(v, u, 1, w);//题目中是无向图
		}
		addedge(0, 1, 2, 0);
		addedge(n, n + 1, 2, 0);
		int ans = mincost(0, n + 1);
		cout << ans << endl;
	}
	return 0;
}