第7周程序作业

A - TT 的魔法猫

众所周知，TT 有一只魔法猫。

这一天，TT 正在专心致志地玩《猫和老鼠》游戏，然而比赛还没开始，聪明的魔法猫便告诉了 TT 比赛的最终结果。TT
非常诧异，不仅诧异于他的小猫咪居然会说话，更诧异于这可爱的小不点为何有如此魔力？

魔法猫告诉 TT，它其实拥有一张游戏胜负表，上面有 N 个人以及 M 个胜负关系，每个胜负关系为 A B，表示 A 能胜过
B，且胜负关系具有传递性。即 A 胜过 B，B 胜过 C，则 A 也能胜过 C。

TT 不相信他的小猫咪什么比赛都能预测，因此他想知道有多少对选手的胜负无法预先得知，你能帮帮他吗？

Input

第一行给出数据组数。

每组数据第一行给出 N 和 M（N , M <= 500）。

接下来 M 行，每行给出 A B，表示 A 可以胜过 B。

Output

对于每一组数据，判断有多少场比赛的胜负不能预先得知。注意 (a, b) 与 (b, a) 等价，即每一个二元组只被计算一次。

Sample Input
3
3 3
1 2
1 3
2 3
3 2
1 2
2 3
4 2
1 2
3 4
Sample Output
0
0
4
思路：本题主要采用弗洛伊德算法，利用赢关系的传递性进行3次弗洛伊德for循环即可求出所有的选手的输赢关系。本题要注意选手与选手之间a[i][j]与a[j][i]不是对称关系。

#include<iostream>
using namespace std;
#define MAX 500
int a[501][501];
int main()
{
	int num;
	cin >> num;
	while (num > 0)
	{
		int n, m;
		cin >> n >> m;
		int sum = n * (n - 1) / 2;
		//n个人
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				a[i][j] = 0;
			}
		}
		int x, y;
		//m个胜负关系
		for (int i = 0; i < m; i++)
		{
			cin >> x >> y;
			a[x][y] = 1;
		}
		for (int k = 1; k <= n; k++)
		{
			for (int i = 1; i <= n; i++)
			{
				if (a[i][k])
				for (int j = 1; j <= n; j++)
				{
					
					{
						a[i][j] = a[i][j] | (a[i][k] & a[k][j]);
					}
					
				}
			}
		}

		for (int i = 1; i <= n; i++)
		{
			for (int j = i + 1; j <= n; j++)
			{
				if (a[i][j]||a[j][i])
				{
				//	cout << 1 << " ";
					sum--;
				}
				
			}
		//	cout << endl;
		}
		cout << sum << endl;
		num--;
	}
	return 0;
}

B - TT 的旅行日记

众所周知，TT 有一只魔法猫。

今天他在 B 站上开启了一次旅行直播，记录他与魔法猫在喵星旅游时的奇遇。 TT
从家里出发，准备乘坐猫猫快线前往喵星机场。猫猫快线分为经济线和商业线两种，它们的速度与价钱都不同。当然啦，商业线要比经济线贵，TT
平常只能坐经济线，但是今天 TT 的魔法猫变出了一张商业线车票，可以坐一站商业线。假设 TT 换乘的时间忽略不计，请你帮 TT
找到一条去喵星机场最快的线路，不然就要误机了！

输入 输入包含多组数据。每组数据第一行为 3 个整数 N, S 和 E (2 ≤ N ≤ 500, 1 ≤ S, E ≤
100)，即猫猫快线中的车站总数，起点和终点（即喵星机场所在站）编号。

下一行包含一个整数 M (1 ≤ M ≤ 1000)，即经济线的路段条数。

接下来有 M 行，每行 3 个整数 X, Y, Z (1 ≤ X, Y ≤ N, 1 ≤ Z ≤ 100)，表示 TT 可以乘坐经济线在车站
X 和车站 Y 之间往返，其中单程需要 Z 分钟。

下一行为商业线的路段条数 K (1 ≤ K ≤ 1000)。

接下来 K 行是商业线路段的描述，格式同经济线。

所有路段都是双向的，但有可能必须使用商业车票才能到达机场。保证最优解唯一。

输出 对于每组数据，输出3行。第一行按访问顺序给出 TT 经过的各个车站（包括起点和终点），第二行是 TT
换乘商业线的车站编号（如果没有使用商业线车票，输出"Ticket Not Used"，不含引号），第三行是 TT 前往喵星机场花费的总时间。

本题不忽略多余的空格和制表符，且每一组答案间要输出一个换行

输入样例
4 1 4
4
1 2 2
1 3 3
2 4 4
3 4 5
1
2 4 3

输出样例
1 2 4
2
5

C - TT 的美梦

这一晚，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 则输出 ‘?’。

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:
?
?
思路;本题主要使用优化后的SPFA算法，主要操作：初始化——>把起点放入队列，（当队列不为空，则不停循环）从队列中取数，对该数每条邻接边进行松弛；检查目前最短路长度，若长度大于等于n，则存在负环，不存在最短路径。要注意的地方有：当最短路径条数大于图中点的个数，存在负环，存在不可达点，本题运用dfs找出所有不可达点

#include<cstdio>
#include<queue>
#include<math.h>
using namespace std;
constexpr auto inf = -1000000;
int tot = 0, T = 0, N = 0, M = 0;
int A = 0, B = 0, Q = 0, P = 0;
int dis[210], con[210], pre[210],head[210], vis[210] ;
int a[210] = { 0 };
struct edge {
	int to, next, w;
}edge[100000];
//给负环打标记 
void dfs(int u) {
	dis[u] = inf;
	for (int i = head[u]; i != 0; i = edge[i].next)
	{
		if (dis[edge[i].to] != inf) {
			dfs(edge[i].to);
		}
	}
}
void init() {
	tot = 0;
	for (int i = 1; i <= 210; i++) 
	{
		head[i] = 0;
		vis[i] = 0;	
		dis[i] = 10000000;	
		con[i] = 0;
	}
}
void Dis(int s) {
	queue<int> q;
	dis[s] = 0;
	vis[s] = 1;
	q.push(s);
	while (!q.empty())
	{
		int u = q.front();
		vis[u] = 0;
		q.pop();
		if (dis[u] == inf) continue;
		for (int i = head[u]; i != 0; i = edge[i].next) 
		{
			int v = edge[i].to;
			int w = edge[i].w;
			if (dis[v] > dis[u] + w)
			{
				con[v] = con[u] + 1;
				if (con[v] >= N) 
				{
					dfs(v);
				}
				dis[v] = dis[u] + w;			
				if (!vis[v] && dis[v] != inf)
				{
					q.push(v);
					vis[v] = 1;
				}
			}
		}
	}
}

int main() {
	scanf("%d", &T);
	for (int i = 1; i <= T; i++)
	{
		scanf("%d", &N);
		for (int k = 1; k <= N; k++) 
		{
			scanf("%d", &a[k]);
		}
		scanf("%d", &M);
		init();
		//添加边
		for (int j = 1; j <= M; j++)
		{
			scanf("%d %d", &A, &B);
			edge[++tot].to = B;
			edge[tot].next = head[A];
			head[A] = tot;
			edge[tot].w = pow(a[B] - a[A], 3);
		}
		Dis(1);
		scanf("%d", &Q);
		printf("Case %d:\n", i);
		for (int j = 1; j <= Q; j++) 
		{
			scanf("%d", &P);
			if (dis[P] < 3 || dis[P] == 10000000) 
			{
				printf("?\n");
			}
			else 
			{ 
				printf("%d\n", dis[P]); 
			}
		}
	}
}