文章目录
题目描述
这一晚，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:
?
?
思路
综述
这道题主要考察的是SPFA解决单源最短路问题，解决负边和负环问题；
SPFA
这个算法和dijkstra类似，dijkstra处理的原则是贪心算法，某个点出堆之后不会再入堆，而SPFA算法会在每次松弛成功之后都入队列，所以这个算法是可以实现重复入队操作；
为什么dijkstra算法处理不了带有负权值的边的图
dijkstra是基于贪心策略，每次都找一个距源点最近的点，然后将该距离定为这个点到源点的最短路径；但如果存在负权边，那就有可能先通过并不是距源点最近的一个次优点，再通过这个负权边，使得路径之和更小，这样就出现了错误。
为什么SPFA可以处理负边：
因为在SPFA中每一个点松弛过后说明这个点距离更近了，所以有可能通过这个点会再次优化其他点，所以将这个点入队再判断一次，
如何判断成环：
两个点之间最短路径：不会超过N-1，所以加一个数组记录两点之间的路径个数即可；
本题边权如何确定
本题是有向图，所以边权就是（目的地繁荣程度 - 出发地繁荣程度）^ 3
过程
Step1:输入
图的存储采用前向星（参考图论）
同样注意每组数据之间的初始化问题；
Step2:SPFA
负环的发现：两点之间的边数大于N-1
此时需要
for (long long i = 0; i < q; i++) {
cin >> L >> R;
cin >> c;
b[L] += c;
if (R != n)
b[R + 1] -= c;
}
代码
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <stdio.h>
using namespace std;
const int MAX = 1e6;
int T, N, M, Q;
int tot = 0;
int dis[205];
int vis[205];
int cnt[205];
struct Edge {
int u, v, w, nxt;
}e[100050];
int head[205];
int a[205];
int fuhuan[205];
void addEdge(int u, int v, int w) {
e[tot].u = u;
e[tot].v = v;
e[tot].w = w;
e[tot].nxt = head[u];
head[u] = tot;
tot++;
}
void init() {
for (int i = 0; i < 205; i++) {
head[i] = -1;
fuhuan[i] = 0;
dis[i] = MAX;
vis[i] = 0;
cnt[i] = 0;
}
tot = 0;
}
int S = 1;
void dfs(int u) {
fuhuan[u] = 1;
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (!fuhuan[v]) {
fuhuan[v] = 1;
dfs(v);
}
}
}
void SPFA() {
queue<int> qq;
dis[S] = 0;
vis[S] = 1;
qq.push(S);
while (!qq.empty()) {
int u = qq.front();
qq.pop();
if (fuhuan[u])continue;
vis[u] = 0;
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
int w = e[i].w;
if (dis[v] > dis[u] + w) {
cnt[v] = cnt[u] + 1;
//cout << "!!:" << dis[v] << endl;
//cout << "term:" << cnt[v] << endl;
if (cnt[v] >= N) {
//找到负环
//cout << "QQQ" << endl;
dfs(v);
}
dis[v] = dis[u] + w;
if (!vis[v]) {
qq.push(v);
vis[v] = 1;
}
}
}
}
}
int main() {
int x, y;
cin >> T;
for (int i = 0; i < T; i++) {
init();
cin >> N;
for (int j = 1; j <= N; j++)cin >> a[j];
cin >> M;
for (int j = 0; j < M; j++) {
cin >> x >> y;
int num = a[y] - a[x];
addEdge(x, y, num * num * num);
}
cin >> Q;
SPFA();
int q;
cout << "Case " << i + 1 << ":" << endl;
//cout << "here" << endl;
//for (int j = 1; j <= N; j++)cout << fuhuan[j] << " ";
//cout << endl;
for (int j = 0; j < Q; j++) {
cin >> q;
if (fuhuan[q] || dis[q] < 3 || dis[q] == MAX)cout << "?" << endl;
else cout << dis[q] << endl;
}
}
}