POJ 2135 Farm Tour（最小费用最大流模板题）

http://poj.org/problem?id=2135

题意很简单，就是给出m条无向边，你要从1到n，然后从n回到1，要求走过的路不能再走，问这样走的最少时间是多少。

一开始我很愚蠢的用正反网络流来跑，这样是错误的。因为这样就没有退流了。

正解：设置一个超级源点0和一个超级汇点n+1，0到1的流量为2，花费为0，n+1到n的流量为2，花费为0.然后我们要求从0到n+1求最小费用，套板子即可。

而且可以注意到，因为一条边只能走一次，所以我们把每条边的流量都设置为1即可。

那么他是无向图，我们怎么增加边呢？

对于单纯的spfa，确实只需要正反两条边都设置一下即可。

但是这题每条边是有费用的，也就是通过这条路的时间。如果你走了这条边，你的费用会+cost。如果你走第二遍发现这条边不走更好，那么你就会退回这条边的流量，并且费用也会-cost。所以我们这题我们一条边需要开四条边才对。超级源点超级汇点除外，只需正反即可。

代码如下：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int INF = 0x7fffffff;
const int maxn = 10000 + 5;
int n, m, ans = 0;
int head[maxn], to[maxn * 4], front[maxn * 4], flow[maxn * 4], cost[maxn * 4], ppp;
int dis[maxn], minflow[maxn];
bool flag[maxn];
pair<int, int> par[maxn];

bool spfa(int s, int e)
{
int u, v;
for(int i = 0; i <= n + 1; i++)
dis[i] = INF;
memset(flag, 0, sizeof(flag));
dis[s] = 0;
minflow[s] = INF;
queue <int> q;
q.push(s);
while(!q.empty())
{
u = q.front();
q.pop();
flag[u] = 0;
for(int i = head[u]; ~i; i = front[i])
{
v = to[i];
if(flow[i] && dis[v] > dis[u] + cost[i])
{
dis[v] = dis[u] + cost[i];
par[v] = (make_pair(u, i));
minflow[v] = min(minflow[u], flow[i]);
if(!flag[v])
{
flag[v] = 1;
q.push(v);
}
}
}
}
if(dis[e] == INF)
return 0;
return 1;
}

void Min_Cost_Max_Flow(int s, int e)
{
int p;
while(spfa(s, e))
{
p = e;
while(p != s) {
flow[par[p].second] -= minflow[e];
flow[par[p].second^1] += minflow[e];
p = par[p].first;
}
ans += dis[e];
}
cout << ans << endl;
}

void add(int u, int v, int f, int c)
{
to[ppp] = v;
front[ppp] = head[u];
flow[ppp] = f;
cost[ppp] = c;
head[u] = ppp++;
}

int main()
{
int u, v, c;
memset(head, -1, sizeof(head));
ppp = 0;
scanf("%d%d", &n, &m);
while(m--)
{
scanf("%d%d%d", &u, &v, &c);
add(u, v, 1, c);
add(v, u, 0, -c);
add(v, u, 1, c);
add(u, v, 0, -c);
}
add(0, 1, 2, 0);
add(1, 0, 0, 0);
add(n, n + 1, 2, 0);
add(n + 1, n, 0, 0);
Min_Cost_Max_Flow(0, n + 1);
return 0;
}