[week7]TT的美梦——SPFA

题意

这一晚，TT 做了个美梦！

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

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

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

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

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 则输出 ‘?’。

输入样例

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:
?
?

提示

---

分析

经历了上一道题的煎熬，这道题就显得友好很多。这道题解决的是存在负权边的单源最短路问题，需要用SPFA解决。

---

• SPFA

1. 什么是SPFA

SPFA是Bellman-ford 算法的队列优化算法。

• Bellman-ford 算法

先介绍一下Bellman-ford 算法的本质：

某一固定到任意点之间的最短路径中包含的边数都一定小于图中点的总数，否则就代表这两个点之间的路径重复到达了至少一个点，这一定不是最短路径，与最短路矛盾，所以原命题成立。

而任意点到固定点的最短路径一定建立在已知最短路径上，即一定是在已知到固定点的最短距离上松弛成功。

因此，对每个点到固定点的边进行最多点个数-1次松弛，一定能得到每个点到固定点的最短距离。

• 队列优化

显然，在Bellman-ford 算法中会重复一些无效的松弛操作，SPFA就是利用队列来避免这些无效的松弛操作。

可以联想Dijkstra算法进行理解：
Bellman-ford 算法一共进行n-1次松弛，每一轮中对所有点到固定点的边进行松弛。
而在第一轮松弛后，此时得到是所有边到起点直接相连的距离，而其中必然有一条是最短路径。
而在第二轮松弛后，此时得到的边包括了连接到第一条最短路径以及仍然为直接与起点相连的路径。其中除去第一次选中的最短路径，一定包含了第二条最短路径。
…
以此类推，显然在每一轮松弛中，松弛操作仅仅发生在最短路径前导结点中已经成功松弛过的结点上。

因此建立一个队列，只将松弛成功的边放入队列中，每次从队列中取点进行松弛。而对每个松弛成功的点应该进行判定，若该点已经被松弛过，则代表其最短路径已经存在。

2. SPFA & Bellman-ford 算法

💡Bellman-ford 算法代码常用模版
复杂度为：O(nm)

💡SPFA 代码常用模版
复杂度为：O(km)

3. 负权环路

在一个图中，并不能保证所有点都一定能与某一固定点连通，因此可能存在一些点到起点的距离为无穷大。

但是除此之外，SPFA所适用的图类型还包含了负权边。也就是存在一些边权为负数。

这就导致，可能存在一种情况，即一个点到起点的路径过程中包含了一个环路，而环路中存在负权边。这会导致，在计算最短路的过程中，算法会不断重复这条环路，因为负权边叠加后只会越来越小，直到无穷小。

这就是负权环路。若一个点到起点的路径上存在负环权路，自然就代表该点到起点不存在所谓的最短路径。

那么如何判断负权环路呢？

根据SPFA的本质可知，每条边最多松弛点数-1次。如果一条边松弛次数大于点数-1次，说明这条路径开始重复经过一点，显然这就代表了该条路径上存在负环权路。

而负环权路上经过的所有点同样也会遇到这样的问题，所以当发现一个属于负环权路的点时，从该点起找到所有与其连通的点，就能找到该负环权路中的所有点并进行避免了。

💡负权环路SPFA代码模版
***

代码实现

**1.标记负环权路 **

为了标记负环权路，我们可以用一个数组来记录所有点被松弛时图中边总共被松弛的次数，以及用一个数组来标记所有处于负环权路中的点。

在SPFA中每当一个邻接点被松弛成功后，该点的松弛次数就为其出发点松弛次数+1。之后就应对该点的松弛次数进行判定，若大于点总数-1，说明该点属于负环权路。

2.如何找到负环权路

此时就是我们经典的图遍历方式派上用场的时刻了！
BFS👉[week2]经典迷宫问题——BFS搜索法
DFS👉[week3]选数问题——DFS搜索法

任何一种搜索法都能找到一个图中与某一固定点相连通的所有点，在搜索过程中将所有到达点标记为负环权路即可。

3.判断输出

当终点到起点的距离为无限大时，说明该点从起点不可到达；若该点被负环权路标记，说明该点不存在与起点之间的最短路。

因此除去题目要求的金额小于3属于不合法情况时，以上两种情况同样表示该点不合法。

---

总结

1. 数组太多的时候清空和初始化真的是一件非常无语的事情👋
2. 为什么会被case输出搞半天！！

---

代码

//
//  main.cpp
//  lab3
//
//

#include <iostream>
#include <vector>
#include <queue>
#include <string.h>
#include <algorithm>
#include <map>
#include <cmath>
#define INFINITE 1e7
using namespace std;

struct edge
{
    int from,to,value;
};

int point[201];         //记录所有点的权值
vector<edge> lines[100000];         //记录所有路
queue<int> q;
int times[201];                 //记录当前点被松弛的次数
bool vis[201],illegal[201];         //前者用于松弛中标记已经松弛过的点，后者用于标记负环点
int path[201];                  //记录路径
int dis[201];                   //记录每个点到起点的距离

void searching(int x)               //找出负环中所有的点（dfs）
{
    for( int i = 0 ; i < lines[x].size() ; i++ )
    {
        if( !illegal[lines[x][i].to] )
        {
            illegal[lines[x][i].to] = true;
            searching(lines[x][i].to);
        }
    }
}

void spfa(int n)
{
    dis[1] = 0;             //初始化起点
    vis[1] = true;
    
    q.push(1);
    
    while( !q.empty() )
    {
        int now = q.front();
        q.pop();
        
        vis[now] = false;           //将当前取出点标记为未松弛
        
        for( int i = 0 ; i < lines[now].size() ; i++ )
        {
            int to = lines[now][i].to;          //到达点
            
            if( dis[to] > dis[now] + lines[now][i].value )      //若到达点可以被松弛
            {
                times[to] = times[now] + 1;     //其松弛次数为出发点的次数+1
                
                if( times[to] >= n )        //若松弛次数大于等于点个数，则存在负环
                {
                    searching(to);          //查找负环中所有点
                    continue;               //该点不能经过
                }
                
                dis[to] = dis[now] + lines[now][i].value;       //更新距离
                path[to] = now;                             //更新路径
                    
                if( !vis[to] )          //若当前点未被松弛过，则将其标记并压入队列中
                {
                    q.push(to);
                    vis[to] = true;
                }
                
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    
    int t = 0,n = 0,m = 0,q = 0,w = 0,a = 0,b = 0,p = 0;
    
    scanf("%d",&t);
    
    for( int j = 1 ; j <= t ; j++ )
    {
        scanf("%d",&n);
        
        for( int i = 1 ; i <= n ; i++ )          //初始化
        {
            dis[i] = INFINITE;
            vis[i] = false;
            times[i] = 0;
            path[i] = 0;
            illegal[i] = false;
            lines[i].clear();
        }
        
        for( int i = 1 ; i <= n ; i++ )        //输入点权值
        {
            scanf("%d",&w);
            point[i] = w;
        }
        
        scanf("%d",&m);
        
        for( int i = 1 ; i <= m ; i++ )        //输入所有边
        {
            scanf("%d %d",&a,&b);
            lines[a].push_back({a,b,static_cast<int>(pow(point[b] - point[a],3))});
            //边的权值就是到达点减去出发点权值的三次方
        }
        
        spfa(n);            //查找所有点到起始点的最短路径
        
        cout<<"Case "<<j<<":"<<endl;
        
        scanf("%d",&q);
    
        while( q-- )            //输出该组信息的所有答案
        {
            scanf("%d",&p);
            
            if( dis[p] < 3 || illegal[p] || dis[p] == INFINITE )  //若其到达起点的距离小于3或在负环中或无法到达
                cout<<"?"<<endl;
            else                            //否则输出距离
                cout<<dis[p]<<endl;
        }
        
        
        
    }
    
    
    return 0;
}