SPFA Algorithm

题意：
有 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:
?
?
解题思路：
题目要求从 1 出发到其他点花费最少的钱，相当于求 1 到其他点的最短路。值得注意的一点是，经过一条道路，TT 收的税可能是负数。图中存在负权边，这是一个含负权边的单源最短路径问题，当什么情况下会输出 ‘?’ ：不可达，最短路小于 3，此时有可能是最短路存在但小于3，也可能是最短路不存在。需要我们判断负环，那些通过负环可以到达的点的最短路均不存在。找到负环后，将负环所在连通块里的点进行遍历打上标记即可，这些点当需要访问时均应该输出问号。
注意事项：
主要是注意图中存在负权边，这样可能出现负环，而输出问号的情况包括：无法达到（即dis为inf），出现负环（即到达该点可以经过负环，所以也不存在最短路径），最短路径长度小于3（即dis小于3）。我们用spfa算法来处理这个图，注意如何判断一条边被松弛的次数大于等于 n，SPFA 中将点加入队列，不容易判断边的松弛次数，可以放宽条件，判断点的入队次数，如果某一点入队 n 次则说明有负环，所以需要一个额外的cnt数组记录点的入队次数用来判断负环的情况。
总结：
spfa的应用问题，本质上是bellman-ford算法的优化，很多情况下可以极大降低算法时间复杂性。我们判断点的入队次数来判断图中是否存在负环，那些通过负环可以到达的点的最短路均不存在。找到负环后，应该将负环所在的连通块里的所有点进行遍历打上标记，这些点当需要访问时均应该输出问号。
参考代码：

#include <iostream>
#include <queue>
#include <limits.h>
#include <cstring>
#include <cmath>
using namespace std;
int n,m;
int num=0;
int a[205],dis[205],inq[205],cnt[205],flag[205];
const int INF=INT_MAX;
struct edge{
    int to, next ,w;
    edge(int a=0,int b=-1,int c=0):to(a),next(b),w(c){}
} e[100010];
int head[205],tot=0;
void add(int x,int y,int w){
    e[tot].to = y;
    e[tot].next = head[x];
    e[tot].w = w;
    head[x] = tot;
    tot++;
}
void set_flag(int v){
    for(int i=head[v];i!=-1;i=e[i].next)
        if(!flag[e[i].to])
        {
            flag[e[i].to]=1;
            set_flag(e[i].to);
        }
    
}


int main(int argc, const char * argv[]) {
    int T;cin>>T;
    while (T--) {
        num++;
        tot=0;
        memset(head, -1, sizeof(head));
        cin>>n;
        for (int i=1; i<=n; i++) {
            cin>>a[i];
        }
        cin>>m;
        for (int i=1; i<=m; i++) {
            int A,B;cin>>A>>B;
            int weight=pow((a[B]-a[A]),3);
            add(A, B, weight);
        }
        for(int i=1;i<=n;++i){
        dis[i] = INF;
        inq[i] = 0;
        cnt[i] = 0;
        flag[i]=0;
        }
        int s=1;
        dis[s] = 0;
        inq[s] = 1;
        queue<int> q;
        q.push(s);
        while(!q.empty()) {
        int u = q.front(); q.pop();inq[u] = 0;
        for(int i=head[u];i!=-1;i=e[i].next) {
        int v = e[i].to;
            if(dis[v] > dis[u] + e[i].w) {
                cnt[v]++;
                dis[v] = dis[u] + e[i].w;
                if(cnt[v] >= n) {
                    set_flag(v);
                    continue;
                }
                if(!inq[v]) {
                     q.push(v);
                    inq[v] = 1;
                        }
                     }
        }
        }
        int Q;cin>>Q;
        cout<<"Case "<<num<<":\n";
        while (Q--) {
            int p;cin>>p;
            if(dis[p]==INF||dis[p]<3||flag[p])cout<<'?'<<endl;
            else cout<<dis[p]<<endl;
        }  
    }
    return 0;
}