week7-作业

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) 等价，即每一个二元组只被计算一次。

---

思路：

这个问题可以用弗洛伊德来解决。通过dis来表示双方的胜负关系 若dis[i][j]=1则表示i胜于j，dis[i][j]=0且dis[j][i]=0即表示i与j无法判断双方的胜负关系。dis[i][j]=max(dis[i][j],dis[i][k]&dis[k][j])则使胜负关系具有传递性。这样就解决了这个问题，通过弗洛伊德算法进行三次遍历就能找到所有dis符合1的，但中间可以进行剪枝，若dis[i][k]==0就知道dis[i][j]肯定不为1，所以只需进行dis[i][k]==1的即可。

---

代码:

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 502	
int dis[maxn][maxn];
void freud(int N) //弗洛伊德算法
{
	for (int k = 1; k <= N; k++)
		for (int i = 1; i <= N; i++)
		{
			if (dis[i][k] == 0) //剪枝
				continue;
			for (int j = 1; j <= N; j++)
			{
				dis[i][j] = max(dis[i][j], dis[i][k] & dis[k][j]); 
			}

		}

}
int main()
{
	ios::sync_with_stdio(false);
	int group;

	cin >> group;
	for (int i = 0; i < group; i++)
	{
		int N, M;
		int A, B;
		int count = 0;
		cin >> N >> M;
		for (int j = 0; j <= N; j++)
			for (int k = 0; k <= N; k++) //初始化dis
				dis[j][k] = 0;
		for (int j = 0; j < M; j++)
		{
			cin >> A >> B;
			dis[A][B] = 1;
		}
		freud(N);
		for (int j = 1; j <= N; j++)
			for (int k = 1; k <= N; k++)
				if (dis[j][k] == 1)
					count++;
		cout << N * (N - 1) / 2 - count << endl;
	}
	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 前往喵星机场花费的总时间。
本题不忽略多余的空格和制表符，且每一组答案间要输出一个换行

思路：

这道题可以利用单源最短路径来解决，当然也可以用SPFA来解决，当然这次为了学习方法使用了单源最短路径。首先采用edge和链式前向星的方式存储X,Y,Z。整个过程需要经过两次的dijkstral。第一次从起点开始，第二次从终点开始跑，来记录单源的最短路。然后找到商业线所用时间的最小值，再与经济线进行比较。首先使用dis来记录每个点的距离，path用来记录经过的路径。初始先让起点放入小根堆中，然后将该点vis设置为1，每次取出堆顶元素，然后进行松弛操作，比较一下e[i].to与 dis1[x]+e[i].w的大小，若大于的化，就进行更新，并且将该点存入小根堆中。在进行dijkstral之后从需要比较从起点到i加上终点到j的距离加上i和j间商业线的w，起点到j的距离和终点到i的距离加上i和j间商业线的w同时还要和使用经济线时的权重进行比较，求出来最小值。最后通过递归输出路径即可。
要点：要注意输出的格式，因为递归输出需要注意空格，这道题因为没用有用的函数存储导致多次PE,修改了很多次，也知道了queue，stack等存储STL的重要性

---

代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int n = 5 * 1e6 + 100;
const int inf = 5 * 1e8;

struct edge
{
	int to;
	int next;
	int w;
}e[n];
priority_queue<pair <int, int> >q;
int head[n], vis[1002], tot;
int dis1[1002], dis2[1002];  //记录距离
int path1[1002], path2[1002]; //记录路径
int N, S, E;

void add(int x, int y, int w)
{
	e[++tot].to = y;
	e[tot].next = head[x];
	e[tot].w = w;
	head[x] = tot;
}

void Dijkstra1(int s)
{
	while (q.size())
		q.pop();
	memset(vis, 0, sizeof(vis));
	for (int i = 1; i <= N; i++)
		dis1[i] = inf;
	dis1[s] = 0;
	q.push(make_pair(0, s));
	while (q.size())
	{
		int x = q.top().second;
		q.pop();
		vis[x] = 1;
		for (int i = head[x]; i != -1; i = e[i].next)
		{
			int y = e[i].to, w = e[i].w;
			if (dis1[y] > dis1[x] + w)
			{
				path1[y] = x;
				dis1[y] = dis1[x] + w;
				q.push(make_pair(-dis1[y], y));
			}
		}
	}
}
void Dijkstra2(int s)
{
	while (q.size())
		q.pop();
	memset(vis, 0, sizeof(vis));
	for (int i = 1; i <= N; i++)
		dis2[i] = inf;
	dis2[s] = 0;
	q.push(make_pair(0, s));
	while (q.size())
	{
		int x = q.top().second;
		q.pop();
		vis[x] = 1;
		for (int i = head[x]; i != -1; i = e[i].next)
		{
			int y = e[i].to, w = e[i].w;
			if (dis2[y] > dis2[x] + w)
			{
				dis2[y] = dis2[x] + w;
				q.push(make_pair(-dis2[y], y));
				path2[y] = x;
			}
		}
	}
}

void output1(int a)
{
	if (a == S)
	{
		printf("%d", a);
		return;
	}
	output1(path1[a]);
	printf(" %d", a);

}
void output2(int a)
{
	printf(" %d", a);
	if (a == E)
		return;
	output2(path2[a]);
}

int main()
{
	int M, K;
	int X, Y, Z;

	int b = 0;
	while (/*cin >> N >> S >> E*/scanf("%d %d %d", &N, &S, &E) != EOF)
	{
		int l = 0, r = 0;
		if (b) printf("\n");
		scanf("%d", &M);
		//cin >> M;
		tot = 1;
		memset(head, -1, sizeof(head));
		memset(path1, -1, sizeof(path1));
		memset(path2, -1, sizeof(path2));
		for (int i = 1; i <= M; i++)
		{
			scanf("%d %d %d", &X, &Y, &Z);
			//cin >> X >> Y >> Z;
			add(X, Y, Z);
			add(Y, X, Z);
		}
		Dijkstra1(S);
		Dijkstra2(E);
		int mint = dis1[E];
		scanf("%d", &K);
		//cin >> K;
		for (int i = 1; i <= K; i++)
		{
			scanf("%d %d %d", &X, &Y, &Z);
			//cin >> X >> Y >> Z;
			if (mint > dis1[X] + dis2[Y] + Z)
			{
				mint = dis1[X] + dis2[Y] + Z;
				l = X;
				r = Y;
			}
			if (mint > dis1[Y] + dis2[X] + Z)
			{
				mint = dis1[Y] + dis2[X] + Z;
				l = Y;
				r = X;
			}
		}
		if (l == 0)
		{
			output1(E);
			printf("\nTicket Not Used\n%d\n", mint);
			//cout << endl << "Ticket Not Used" << endl << mint << endl;
		}
		else
		{
			output1(l);
			output2(r);
			printf("\n%d\n%d\n", l, mint);
			//cout << endl << l << endl << mint << endl;
		}
		b = 1;

	}
	return 0;
}

---

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

---

思路：

这道题因为有负数和环路，所以应当使用Bellman−Ford算法-SPFA最为适用。存储图的方式使用链式前向星。
下面分别介绍各数组的作用：inq代表标记经过的点，dis标记两点之间的距离，cnt用来记录松弛的次数，pre记录是不是负环。
首先在进行spfa之前需要对所有的数组初始化，对其他数组初始化为0，dis初始化为inf,然后将起点压入队列，如果起点不为空，则进行循环，每次取出队首元素，删除队首元素，并将inq的该点设置为0，然后对邻接点进行松弛，对于dis[v] > dis[u] + e[i].w的点inq设置为1并且cnt+1,并将邻接点压入队列当中，如果cnt[v] >= N则证明存在负环，然后dfs该点，找到负环并用pre标记该点。进行spfa之后对所有点进行判断，若pre=0且dis[P] < 3 || dis[P] == inf则输出‘？’，否则输出dis值。

---

代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
const int maxn = 500;
const int maxm = 100050;
int tot,head[maxn],dis[maxn],cnt[maxn],inq[maxn],pre[maxn];
int T,N, M,A,B,Q,P,g[maxn];
queue<int>q;

struct edge
{
	int to;
	int w;
	int next;

}e[maxm];

void add(int x, int y, int w)
{
	e[tot].to = y;
	e[tot].w = w;
	e[tot].next = head[x];
	head[x] = tot;
	tot++;
}

void dfs(int v)
{
	pre[v] = 1;
	for (int i = head[v]; i != -1; i = e[i].next) //找到负环
	{
		if (pre[e[i].to] == 0)
			dfs(e[i].to);
	}
}

void spfa(int a)
{
	while (!q.empty()) q.pop();
	for (int i = 1; i <= N; i++)
	{
		dis[i] = inf;
		inq[i] = 0;
		cnt[i] = 0;
		pre[i] = 0;
	}
	dis[a] = 0;
	inq[a] = 1;
	q.push(a);
	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 (pre[v]) continue;
			if (dis[v] > dis[u] + e[i].w)
			{
				dis[v] = dis[u] + e[i].w;
				if (!inq[v])
				{
					q.push(v);
					inq[v] = 1;
					cnt[v] = cnt[v] + 1;
					if (cnt[v] >= N)
					{
						dfs(v);
					}
				}
				
			}
			
		}
	}
}

int main()
{
	cin >> T;
	int count = 1;
	for (int i = 1; i <= T; i++)
	{
		cin >> N;
		for (int j = 1; j <= N; j++)
			cin >> g[j];
		tot = 0;
		memset(head, -1, sizeof(head));
		cin >> M;
		for (int j = 1; j <= M; j++)
		{
			cin >> A >> B;
			add(A, B, pow(g[B] - g[A], 3));

		}
		spfa(1);
		cout << "Case" << " " << count << ":" << endl;
		cin >> Q;
		for (int j = 1; j <= Q; j++)
		{
			cin >> P;
			if (pre[P] == 0)
			{
				if (dis[P] < 3 || dis[P] == inf)
					cout << "?" << endl;
				else
					cout << dis[P] << endl;
			}
			else cout << "?" << endl;
		}
		count++;

	}
	return 0;
}