TT 的美梦（SPFA）

题意：

这一晚，TT 做了个美梦！

在梦中，TT 的愿望成真了，他成为了喵星的统领！喵星上有 N 个商业城市，编号 1 ～ N，其中 1 号城市是 TT 所在的城市，即首都。

喵星上共有 M 条有向道路供商业城市相互往来。但是随着喵星商业的日渐繁荣，有些道路变得非常拥挤。正在 TT 为之苦恼之时，他的魔法小猫咪提出了一个解决方案！TT 欣然接受并针对该方案颁布了一项新的政策。

具体政策如下：对每一个商业城市标记一个正整数，表示其繁荣程度，当每一只喵沿道路从一个商业城市走到另一个商业城市时，TT 都会收取它们（目的地繁荣程度 - 出发地繁荣程度）^ 3 的税。

TT 打算测试一下这项政策是否合理，因此他想知道从首都出发，走到其他城市至少要交多少的税，如果总金额小于 3 或者无法到达请悄咪咪地打出 ‘?’。

输入输出要求：

输入：第一行输入 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 号点的最少税费。

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

样例输入：

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

样例输出：

Case 1:
3
4
Case 2:
?
?

思路：

题意分析：
（目的地繁荣程度 - 出发地繁荣程度）^ 3可能为负值，且已知起点为1，所以基本确定使用SPFA

SPFA：
在Bellman-ford算法中如何判断负环的存在？如果存在负环，那么最短路经过的边数会大于等于n
一些边被松弛的次数会大于等于n
如果在第n 次松弛操作时还存在边能够被成功松弛，那么图中存在负环

具体做法：
如何判断最短路不存在：通过负环可以到达的点的最短路均不存在
这里确定同个点属于负环后使用dfs遍历负环上的点并标记，这里有一个可以剪枝的地方，一旦该点已经标记属于负环了，就不必再进行下面的循环操作

注意点：
从一个城市到另一个城市的税收，其实这是个有向图，加边的时候注意一点

代码：

#include<cstdio>
#include<queue>
#include<cmath>
using namespace std;
const int inf=5*1e8;

int T,N,M,A,B,Q,P,tot;
int a[201],dis[201],cnt[201],vis[201];				//记录最短路径，当前最短路的边数,点是否遍历过
int pre[201],fvis[201];						//记录是否属于负环 
queue<int> q; 

struct edge{
	int v,nxt,w;
}e[100000]; 
int head[201];

void add(int a,int b,int c){				//加边 
	e[++tot].v=b; e[tot].nxt=head[a]; e[tot].w=c;
	head[a]=tot;
}

void init(){
	for(int i=1;i<=N;i++){
		dis[i]=inf; cnt[i]=0; head[i]=0;
		vis[i]=0;  fvis[i]=0;  pre[i]=0;
	}
	tot=0;
}

void dfs(int s){
	fvis[s]=1;										//标记属于负环 
	for(int i=head[s];i!=0;i=e[i].nxt){
		if(fvis[e[i].v]!=1)
			dfs(e[i].v);
	}
} 

void SPFA(int s){
	dis[s]=0; vis[s]=1;
	q.push(s);
	while(!q.empty()){
		int u=q.front(); q.pop();
		vis[u]=0;						/
		if(fvis[u]) continue;						//已经属于负环 
		for(int i=head[u];i!=0;i=e[i].nxt){
			int v=e[i].v;
			if(dis[v]>dis[u]+e[i].w){			//需要松弛 
				cnt[v]=cnt[u]+1;					//更新最短边边数
				if(cnt[v]>=N) 					//负环
					dfs(v);							//找到能到的点 
				dis[v]=dis[u]+e[i].w;				//更新最短路长度
				pre[v]=u;
				if(!vis[v]){
					q.push(v);						//未到达过，扔到队列
					vis[v]=1; 
				} 
			}
		}
	}
} 

int main(){
	scanf("%d",&T);
	for(int i=1;i<=T;i++){
		scanf("%d",&N);
		init();
		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);
			int weight=pow(a[B]-a[A],3);
			add(A,B,weight);
		}
		SPFA(1);
		scanf("%d",&Q);
		printf("Case %d:\n",i);
		for(int j=0;j<Q;j++){
			scanf("%d",&P);
			if(dis[P]==inf||dis[P]<3||fvis[P])
				printf("?\n");
			else printf("%d\n",dis[P]);
		} 
	}
	return 0;
}