CODE[VS] 1033 蚯蚓的游戏问题（最大费用最大流？）

http://codevs.cn/problem/1033/

这是一道网络流的题目，还是很模版的，比较简单。

我们看到了这一道题是很典型的点权，每个点有他的价值，然后题目也说了，每次蚯蚓走的时候不能和以前蚯蚓走过的路径重复。最终我们要求蚯蚓走完后所能得到的最大价值。我们很容易联想到这是一道网络流的题目，因为我们需要退流的思想，也就是要有反向边提供给我们后悔的机会。

那么我们从网络流入手，考虑到蚯蚓走的路径不能是已经走过的，我们建立起一个网络流的图，并且把每条边的流量都设置为1，每次我们找到增广路之后相当于删除了一条路一样。我们把费用当成边的价值，但是题目所说的价值本身是一个点权，这里我们就要想到拆点，一个点拆为两个连起来作为一条边，并且把这条边的价值设置为点权的价值。

然后跑一遍最小费用最大流就好了。

我遇到的问题是，我使用了超级源点，它连出去的边，流量都是1，价值都是0，我们跑spfa找最长路的时候，松弛条件肯定是dis[v] < dis[u] + cost[i]，这个条件本身没有问题，但是我们会发现这样超级源点就出不去了，因为这些边的价值都是0。我抖机灵了一下，决定把dis[s]=1，也就是超级源点的价值设置为1，这样只要有增广路，我们肯定可以跑下去，也可以防止某些点权本身就是0的情况导致无法更新。

代码如下：（调试了好久啊)

#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 4050 * 2 + 5;
int n, m, k, Point_Number;
int head[maxn], to[maxn], front[maxn], flow[maxn], cost[maxn], ppp;
int dis[maxn], minflow[maxn], cnt[maxn];
bool flag[maxn];
pair<int, int> par[maxn];

struct node
{
	int val, id;
}G[65][65];

bool spfa(int s, int e)
{
	int u, v;
	for(int i = 0; i <= e; i++)
		dis[i] = 0;
	memset(flag, 0, sizeof(flag));
	memset(minflow, 0, sizeof(minflow));
	memset(cnt, 0, sizeof(cnt));
	minflow[s] = INF;
	flag[s] = 1;
	cnt[s]++;
	dis[s] = 1;
	queue <int> q;
	q.push(s);
	while(!q.empty())
	{
//		cout << "u : " << u << endl;
		u = q.front();
		q.pop();
		if(cnt[u] > e)
			return 0;
		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;
					cnt[v]++; 
					q.push(v);
				}
			}
		}
	}
	if(dis[e] == 0)
		return 0;
	return 1;
}

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

void add(int u, int v, int c)
{
	to[ppp] = v;
	front[ppp] = head[u];
	flow[ppp] = 1;
	cost[ppp] = c;
	head[u] = ppp++;
	
	to[ppp] = u;
	front[ppp] = head[v];
	flow[ppp] = 0;
	cost[ppp] = -c;
	head[v] = ppp++;
	
//	cout << ppp << endl;
}

int main()
{
    int u, v, flow, tmp, cnt;
    while(scanf("%d%d%d", &m, &n ,&k) != EOF)
	{
		cnt = 0;
		ppp = 0;
	    memset(G, 0, sizeof(G));
	    memset(head, -1, sizeof(head));
	    for(int i = 0; i < m; i++)
	    {
	    	for(int j = 0; j < n + i; j++)
	    	{
	    		scanf("%d", &G[i][j].val);
	    		G[i][j].id = ++cnt;
//	    		cout << i << " " << j << ",";
	    	}
//	    	cout << endl;
	    }
//	    cout << "cnt:" << cnt << endl;
	    Point_Number = cnt;
	    
	    for(int i = 0; i < n; i++)
	    	add(0, G[0][i].id, 0);
		
		for(int i = 0; i < m; i++)
	    	for(int j = 0; j < n + i; j++)
	    	{
//	    		cout << G[i][j].id << " " << Point_Number + G[i][j].id << endl;
	    		add(G[i][j].id, Point_Number + G[i][j].id, G[i][j].val);
	    		for(int k = 0; i != m - 1 && k < 2; k++)
	    		{
//	    			cout << Point_Number + G[i][j].id << " " << G[i + 1][j + k].id << endl; 
	    			add(Point_Number + G[i][j].id, G[i + 1][j + k].id, 0);
	    		}
			}
		
		for(int i = 0; i < m + n - 1; i++)
		{ 
//	    	cout << G[m - 1][i].id + Point_Number << " " << 2 * Point_Number + 1 << endl;
			add(G[m - 1][i].id + Point_Number, 2 * Point_Number + 1, 0);
	    }
	    	
	    Min_Cost_Max_Flow(0, 2 * Point_Number + 1);
    }
}