Wek7 城市税SP算法

问题描述：

这一晚，TT 做了个美梦！
在梦中，TT 的愿望成真了，他成为了喵星的统领！喵星上有 N 个商业城市，编号 1 ～ N，其中 1 号城市是 TT 所在的城市，即首都。
喵星上共有 M 条有向道路供商业城市相互往来。但是随着喵星商业的日渐繁荣，有些道路变得非常拥挤。正在 TT 为之苦恼之时，他的魔法小猫咪提出了一个解决方案！TT 欣然接受并针对该方案颁布了一项新的政策。
具体政策如下：对每一个商业城市标记一个正整数，表示其繁荣程度，当每一只喵沿道路从一个商业城市走到另一个商业城市时，TT 都会收取它们（目的地繁荣程度 - 出发地繁荣程度）^ 3 的税。
TT 打算测试一下这项政策是否合理，因此他想知道从首都出发，走到其他城市至少要交多少的税，如果总金额小于 3 或者无法到达请悄咪咪地打出 ‘?’。

解题思路：

抽取题意：城市之间互相连通，且路径长度为：（目的地繁荣程度 - 出发地繁荣程度）^ 3 。求出发地到所有目的地的纳税额，且在该两种情况下不输出纳税额，而是输出‘？’：能到达但是总金额小于3、无法到达。
可知，路径长度可能为负值，所以该题不能再用Dij算法，而且该图还可能出现负环，只能采用SPFA算法。
①当点 u 是 S 不可达时，显然 S 到 u 的最短路不存在，dis[u]=INF。
②当图中存在负环时，那么可以沿着负环不断走下去，那么最短路长度为负无穷，没有意义。
难点在于怎样判断负环以及得到负环的可到达点，SPFA算法的核心思想就是：到任何点的边数一定小于顶点数。如果存在负环，一定会违背这个条件，为此，创建一个到达点i经过的边数数组cnt[i]，以及点[i]是否是负环的可到点able数组，如果点y经由点x到达，则cnt[y]=cnt[x]+1，若cnt[y]>n-1，则对点y DFS，可到达点able[i]都置为0，入队时:避免重复点（即已经在队列里exist[i]为1）入队，避免负环点入队。
note::!!注意输出case！！（因为case浪费了两天假期/(ㄒoㄒ)/~~）

Input:
第一行输入 T，表明共有 T 组数据。（1 <= T <= 50）
对于每一组数据，第一行输入 N，表示点的个数。（1 <= N <= 200）
第二行输入 N 个整数，表示 1 ～ N 点的权值 a[i]。（0 <= a[i] <= 20）
第三行输入 M，表示有向道路的条数。（0 <= M <= 100000）
接下来 M 行，每行有两个整数 A B，表示存在一条 A 到 B 的有向道路。
接下来给出一个整数 Q，表示询问个数。（0 <= Q <= 100000）
每一次询问给出一个 P，表示求 1 号点到 P 号点的最少税费。

Output:
每个询问输出一行，如果不可达或税费小于 3 则输出 ‘?’。

Sample Input:
2
5
6 7 8 9 10
6
1 2
2 3
3 4
1 5
5 4
4 5
2
4
5
10
1 2 4 4 5 6 7 8 9 10
10
1 2
2 3
3 1
1 4
4 5
5 6
6 7
7 8
8 9
9 10
2
3 10

Sample Output:
Case 1:
3
4
Case 2:
?
?

(OH CASE!)

实验代码：

#include<cstdio>
#include<limits.h>
#include<queue>
#include<iostream>
#include <math.h>
using namespace std;
const int inf = 1e9 + 7;
int head[250];
int a[250];
int ans[250]; 
struct Edge
{
	int v;
	int w;
	int next;			
};	
Edge edge[100050];
bool able[250];			//表示这些点不可达
bool vis[250];			
bool exist[250];		//表示是否在队列里 
int dis[250],cnt[250];	//dis数组表示距离，cnt数组表示边数 
int N,ecnt;
void initialize()		 
{
	ecnt=0;
	for(int i=0;i<=N;i++)
	{
		head[i]=-1;
		vis[i]=0;			
	} 
}
void insert_Edge(int u,int v)
{
	edge[ecnt].v=v;
	edge[ecnt].w=(a[v]-a[u])*(a[v]-a[u])*(a[v]-a[u]);		
	edge[ecnt].next=head[u];
	head[u]=ecnt;
	ecnt++; 
}
void dfs(int s)
{
	able[s]=0;		
	vis[s]=1;		
	for(int i=head[s];i!=-1;i=edge[i].next)
	{
		int x=edge[i].v;		
		if(!vis[x])			
			dfs(x); 
	}
} 
queue<int> q;
void SPFA(int s)
{
	for(int i=1;i<=N;i++)
	{			
		able[i]=1;			
		cnt[i]=0;			
		dis[i]=inf;			 
		exist[i]=0;			
	}
	dis[s]=0,exist[s]=1; 	
	q.push(s);
	while(q.size()) 
	{
		int x=q.front();
		q.pop();
	 	exist[x]=0;
	 	if(!able[x])			  
		 	continue; 
		for(int i=head[x];i!=-1;i=edge[i].next)
		{
			int y=edge[i].v;
			if(dis[y]>(dis[x]+edge[i].w))
			{
				dis[y]=dis[x]+edge[i].w;
				cnt[y]=cnt[x]+1;
				if(cnt[y]>=N)
				{
					dfs(y);	
				} 
				if(!exist[y]&&able[y])	
				{
					exist[y]=1;
					q.push(y);
				}
			}
		} 
	}
} 
int main()
{
	int T,M;					 
	int A,B,Q;				
	scanf("%d",&T);
	int cot=0;
	for(int i=0;i<T;i++)
	{
		cot++;
		scanf("%d",&N);			
		initialize();			
		for(int j=1;j<=N;j++)
		{
			scanf("%d",&a[j]);		
		}
		scanf("%d",&M);				
		for(int j=0;j<M;j++)		
		{
			scanf("%d%d",&A,&B);
			insert_Edge(A,B);
		}
		SPFA(1);
		scanf("%d",&Q); 
		printf("Case %d:\n",cot);
		for(int j=0;j<Q;j++)
		{
			scanf("%d",&A);			
			if(able[A]&&dis[A]<3||!able[A]||(dis[A]==inf)) 
				printf("?\n");
			else
				printf("%d\n",dis[A]);
		}
	}
	return 0;
}