程序设计思维与实践 Week7 作业

A - 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

---

思路：求闭包，一个图，很多点，用大于号连接，求关于这些大于号的闭包，胜负关系记录在二维数组dis[a][b]中，0为不确定，1为a<b,用弗洛伊德算法枚举出任意3个点即可：

		for (size_t k = 1; k <= N; k++)//中继点
			for (size_t i = 1; i <= N; i++)
			{
				if (dis[i][k] == 0) continue;
				for (size_t j = i + 1; j <= N; j++)
					dis[i][j] = dis[i][j] || dis[k][j];
			}

注意优化：如果dis[i][k]==0，则i,k关系不确定，就不用再看j了。

#include <iostream>

using namespace std;

int dis[505][505];//1表示a>b，0表示无法判断，dis[a][b],dis[b][a]都为0表示ab之间胜负无法判断

int main()
{
	int K, N, M; cin >> K;
	while (K--)
	{
		cin >> N >> M;
		while (M--)
		{
			int a, b; cin >> a >> b;
			dis[a][b] = 1;
		}
		for (size_t k = 1; k <= N; k++)
			for (size_t i = 1; i <= N; i++)
			{
				if (dis[i][k] == 0) continue;
				for (size_t j = i + 1; j <= N; j++)
					dis[i][j] = dis[i][j] || dis[k][j];
			}
		int count = 0;

		for (size_t i = 1; i <= N; i++)
			for (size_t j = i + 1; j <= N; j++)
				if (!(dis[i][j] || dis[j][i])) count++;
		cout << count << '\n';
		for (size_t i = 1; i <= N; i++)
			for (size_t j = 1; j <= N; j++)
				dis[i][j] = 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

---

思路：因为最多只用一条商业线，可以枚举每条线，比如这条线两端是AB两点，那我只需要知道A到S的最短和B到E的最短加上本身权W即可。就是一个求单源最短路径问题。用dijkstra求出从S和从E为源点到其他点的距离，分别存在dis1,dis2中，另外顺便记录路线，把前一个点存在数组pre1，pre2中，需要注意一点，对于pre1，他是记录的从S点开始的路径，是逆序记录的，而pre2与之相反，记录的是顺序，输出时要分开实现。

void output1(int x)//pre记录的是前面的
{
	if (x == S)
	{
		cout << x; 
		return;
	}
	output1(pre1[x]);
	cout << " " << x;
	
}

void output2(int x)//pre记录的是后面的
{
	while (x != E)
	{
		cout << " " << x;
		x = pre2[x];
	}
	cout << " " << x;
}

#include <iostream>
#include <queue>
#include <stack>
#include <string>
#define inf 0x0fffffff
using namespace std;

priority_queue<pair<int, int>> q;
struct Edge
{
	int to, next, w;
}Edges[3000];
struct Edge2
{
	int u, v, w;//商务线
}Edge2s[1005];
int head[505], tot, tot2, vis[505], dis1[505], dis2[505], pre1[505], pre2[505], N, S, E, M, K;
bool isFirst = true;
void addEdge(int u, int v, int w)
{
	Edges[++tot] = { v, head[u], w };
	head[u] = tot;
}
void dijkstra(int s, int* dis, int* pre)
{
	for (size_t i = 1; i <= N; i++) dis[i] = inf, vis[i] = 0;
	dis[s] = 0;
	q.push(make_pair(0, s));
	while (q.size())
	{
		auto t = q.top(); q.pop();
		int r = t.second;
		if (vis[r]) continue;
		vis[r] = 1;
		for (int i = head[r]; i != 0; i = Edges[i].next)
		{
			int v = Edges[i].to, w = Edges[i].w;
			if (dis[v] > dis[r] + w)
			{
				dis[v] = dis[r] + w;
				pre[v] = r;
				q.push(make_pair(-dis[v], v));
			}
		}
	}
}


void output1(int x)//pre记录的是前面的
{
	if (x == S)
	{
		cout << x; 
		return;
	}
	output1(pre1[x]);
	cout << " " << x;
	
}

void output2(int x)//pre记录的是后面的
{
	while (x != E)
	{
		cout << " " << x;
		x = pre2[x];
	}
	cout << " " << x;
}
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	while (cin >> N >> S >> E)
	{
		tot = tot2 = 0;
		for (int i = 1; i <= N; i++)
		{
			head[i] = 0;
		}
		cin >> M;
		while (M--)
		{
			int X, Y, Z; cin >> X >> Y >> Z;
			addEdge(X, Y, Z);
			addEdge(Y, X, Z);
		}
		cin >> K;
		while (K--)
		{
			int X, Y, Z; cin >> X >> Y >> Z;
			Edge2s[++tot2] = { X,Y,Z };
		}
		dijkstra(S, dis1, pre1);
		dijkstra(E, dis2, pre2);

		int minL = inf, a, b;
		for (int i = 1; i <= tot2; i++)
		{
			int u = Edge2s[i].u, v = Edge2s[i].v, w = Edge2s[i].w;
			if (dis1[u] + dis2[v] + w < minL)
			{
				minL = dis1[u] + dis2[v] + w;
				a = u, b = v;
			}
			if (dis2[u] + dis1[v] + w < minL)
			{
				minL = dis2[u] + dis1[v] + w;
				a = v, b = u;
			}
		}
		if (!isFirst) cout << '\n';
		else isFirst = false;
		if (minL > dis1[E])
		{
			minL = dis1[E];
			output1(E);
		}
		else
		{
			output1(a);
			output2(b);
		}
		cout << '\n';
		if (minL < dis1[E]) cout << a << '\n';
		else cout << "Ticket Not Used" << '\n';
		cout << minL << '\n';
	}
}

总结：注意一下这题的输出格式；另外踩了个坑，inf设置的时候别太大，不然会溢出的。

---

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

---

思路：还是一个单源最短路径问题，但是有负权值，所以不能用dijkstra，要用spfa。具体做法是：对已经松弛过的前导点，松弛他的所有边，并把邻接点如队列（如果队列中没有该点，判断方法是用数组inq记录）。还有一个问题是有可能会出现负环，那就会一直循环了，因为每次松弛都会更新，处理方法是记录一个cnt数组，把每个点对应路径的长度记录下来，如果超过了点数，则说明有了负环，那么把这个点能到达的点记录一下，被记录的点没有最短路。

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>
#include <string>
#include <cstring>
using namespace std;

constexpr int maxn = 205, inf = 0x00ffffff;
struct Edge
{
	int u, v, w;
};
vector<Edge> G[maxn];
//u->v的有向线段，权值是v-u
void addEdge(int u, int v, int w)
{
	G[u].push_back({ u, v, w });
}
int a[maxn], dis[maxn], inq[maxn], cnt[maxn], flag[maxn], T, N, M, Q, c;

void Sign(int s)
{
	queue<int> q;
	while (!q.empty()) q.pop();
	q.push(s); flag[s] = true;
	while (!q.empty())
	{
		int x = q.front(); q.pop();
		for (Edge e : G[x])
		{
			int y = e.v;
			if (!flag[y]) 
			{
				q.push(y);
				flag[y] = true;
			}
		}
	}
}
void Spfa(int s)
{
	queue<int> q;
	for (int i = 1; i <= N; i++)
	{
		inq[i] = cnt[i] = flag[i] = 0;
		dis[i] = inf;
	}
	dis[s] = 0, inq[s] = 1;
	q.push(s);
	while (q.size())
	{
		int u = q.front(); q.pop();
		inq[u] = 0;
		for (Edge e : G[u])
		{
			int v = e.v, w = e.w;
			if (dis[v] > dis[u] + w)
			{
				dis[v] = dis[u] + w;
				cnt[v] = cnt[u] + 1;
				if (cnt[v] >= N)
				{
					Sign(v);
					continue;
				}//出现负环了搜一下
				if (!inq[v] && !flag[v])
				{
					q.push(v);
					inq[v] = 1;
				}
			}
		}
	}

}
int main()
{
	cin >> T;
	while (T--)
	{
		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;
			addEdge(A, B, pow(a[B] - a[A], 3));
		}
		Spfa(1);
		cin >> Q;
		cout << "Case " << ++c << ":\n";
		while (Q--)
		{
			int P; cin >> P;
			if (flag[P] || dis[P] < 3 || dis[P] == inf) cout << "?\n";
			else cout << dis[P] << '\n';
		}
		memset(a, 0, sizeof(a));
		for (int i = 1; i <= N; i++)
			G[i].clear();
	}
}