程序设计思维与实践 Week7 作业 (1/2/智能班)

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

思路

对于给定的数据A B，则代表A可以胜过B，所以可以用有向边代表这类关系，而且由于胜负具有传递性，则两点间的胜负关系就可以表示成是否连通了，所以，可以通过Floyd算法求得两点间是否连通。

其中，对于任意两点a,b，若a不可达b且b不可达a，则两点胜负关系未知，ans++，最后输出ans即可。

Floyd算法

常用于求取图中任意两点之间的距离，设\(f[x][y]\)为x和y之间的距离，则\(f[x][y]=min(f[x][y],f[x][k]+f[k][y])\)为更新表达式，经过k次迭代（k为点个数），即可得到各点间最小距离。

Floyd算法还可以用于求得任意两点间的关系，这种关系体现在\(f[x][y]\)上，只需要对\(f[x][y]\)进行更改即可。

注意k循环在外面，然后是i、j，复杂度为\(O(n^3)\)。

代码

#include<iostream>
using namespace std;
int dis[610][610];
int t,n,m;
int main(){
//	freopen("in1.txt","r",stdin);
	cin>>t;
	while(t){
		int ans = 0;
		t--;
		scanf("%d%d",&n,&m);
		int a,b;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				dis[i][j] = 0;
			}
		}
		while(m){
			m--;
			scanf("%d%d",&a,&b);
			dis[a][b] = 1;
		}
		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] = dis[i][j]||(dis[i][k]&&dis[k][j]);
				}
			}
		}
		for(int i=1;i<=n;i++){
			for(int j=i+1;j<=n;j++){
				if((dis[i][j]==0)&&(dis[j][i]==0)) ans++;
			}
		}
		printf("%d\n",ans);
	}
	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

思路

如果没有商业车票，那么只需要按照单源最短路输出即可。

但是现在，有了商业车票，假设在路段u地使用商业票到达v地，那么对于从出发点到u的路径就是以出发点为源点到达u的最短路（反证法证明），对于从v到目的地的路径就是以目的地为源点到达v的最短路，所以最后的结果一定是某条商业线加上两条单源最短路，所以跑这两条单源最短路然后枚举所有商业线即可。

Dijkstra算法

用于求得无负权边的单源最短路问题。

每次从堆中取出一点，遍历这个点的所有邻接边进行松弛操作，例如对x-y进行松弛，若\(dis[y]>dis[x]+w\)，则将\(dis[y]\)更新，最后得到的dis数组即为答案。

代码

#include<iostream>
#include<queue>
#include<stack>
#include<vector>
using namespace std;
#define inf 200000000
int n,s,e,m,k;
int edge[510][510];
int pre1[510],pre2[510];
int dis1[510],dis2[510];
bool vis1[510],vis2[510];
void initial(){
	for(int i=0;i<510;i++){
		vis1[i] = 0;
		vis2[i] = 0;
		dis1[i] = inf;
		dis2[i] = inf;
		pre1[i] = -1;
		pre2[i] = -1;
	}
	for(int i=0;i<510;i++){
		for(int j=0;j<510;j++){
			edge[i][j] = 0;
		}
	}
}
void add(int i,int j,int w){
	edge[i][j] = w;
	edge[j][i] = w;
}
typedef struct Edge{
	int i,j,w;
}Edge;
priority_queue<pair<int,int> > q;
void dj(){
	dis1[s] = 0;
	q.push(make_pair(0,s));
	while(q.size()){
		int x = q.top().second;
		q.pop();
		if(vis1[x]) continue;
		vis1[x] = 1;
		for(int i=1;i<=n;i++){
			if(edge[x][i]==0)	continue;
			int w = edge[x][i];
			if(dis1[i]>dis1[x]+w){
				dis1[i] = dis1[x] + w;
				pre1[i] = x;
				q.push(make_pair(-dis1[i],i));
			}
		}
	}
}
void dj2(){
	dis2[e] = 0;
	q.push(make_pair(0,e));
	while(q.size()){
		int x = q.top().second;
		q.pop();
		if(vis2[x]) continue;
		vis2[x] = 1;
		for(int i=1;i<=n;i++){
			if(edge[x][i]==0)	continue;
			int w = edge[x][i];
			if(dis2[i]>dis2[x]+w){
				dis2[i] = dis2[x] + w;
				pre2[i] = x;
				q.push(make_pair(-dis2[i],i));
			}
		}
	}
}
int main(){
	freopen("in2.txt","r",stdin);
//	freopen("ou2.txt","w",stdout);
	int x,y,z;
	Edge tmp;
	bool first_in = true;
	while(cin>>n>>s>>e){
		if(!first_in){
			cout<<endl;
		}
		first_in = false;
		initial();
		scanf("%d",&m);
		vector<Edge> v;
		for(int i=1;i<=m;i++){
			scanf("%d%d%d",&x,&y,&z);
			add(x,y,z);
		}
		scanf("%d",&k);
		for(int i=1;i<=k;i++){
			scanf("%d%d%d",&x,&y,&z);
			tmp.i = x;
			tmp.j = y;
			tmp.w = z;
			v.push_back(tmp);
		}
		dj();
		dj2();
		int result_i,result_j;
		int ans = inf;
		while(v.size()){
			int ti = v.back().i, tj = v.back().j, tw = v.back().w;
			v.pop_back();
			int td1 = dis1[ti]+tw+dis2[tj];
			int td2 = dis1[tj]+tw+dis2[ti];
			int tans = min(td1,td2);
			if(ans>tans){
				ans = tans;
				if(td1<=td2){
					result_i = ti;
					result_j = tj;
				}
				else{
					result_i = tj;
					result_j = ti;
				}
			}
		}
		if(dis1[e]!=-1) ans = min(dis1[e],ans);
		vector<int> out;
		stack<int> out1;
		queue<int> out2;
		int ti = result_i;
		int	tj = result_j;
		if(ans==dis1[e]){
			ti = e;
			tj = -1;
		}
		while(ti!=-1){
			out1.push(ti);
			ti = pre1[ti];
		}
		while(tj!=-1){
			out2.push(tj);
			tj = pre2[tj];
		}
		while(out1.size()){
			out.push_back(out1.top());
			out1.pop();
		}
		while(out2.size()){
			out.push_back(out2.front());
			out2.pop();
		}
		for(int i=0;i<out.size()-1;i++){
			printf("%d ",out[i]);
		}
		printf("%d\n",out.back());
		if(ans!=dis1[e]) cout<<result_i<<endl;
		else cout<<"Ticket Not Used"<<endl;
		cout<<ans<<endl;
	}
	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 则输出 '?'。

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求解，而对于输出‘?’的情况，可能是不可达或者最短路小于3，而对于负环，最短路一定不存在，所以对存在负环的点进行bfs即可得到所有可通过负环到达的点。

SPFA算法

Bellman-ford算法：

对图中的每条边进行松弛操作，由于最短路的路径条数小于点的个数，所以只需要进行松弛点数-1轮即可。如果松弛轮数超过点数，那么图中存在负环。

SPFA算法：

对Bellman-ford算法进行的队列优化，在队列中存放已经松弛成功的点，每次从队首取点并松弛其邻接点，如果松弛成功，则将此邻接点放入队列。

时间复杂度平均为\(O(km)\)。

代码

#include<iostream>
#include<queue>
#include<cmath>
#define inf 5*1e8
using namespace std;
int t,n,m,pq;
int dis[500],pre[500],inq[500],a[500],cnt[500];
bool huan[500],bv[500];
struct edge {
	int to,w;
};
queue<int> q;
vector<edge> G[500];
void initial(){
	for(int i=0;i<500;i++){
		G[i].clear();
	}
}
void bfs(int v){
	queue<int> qq;
	qq.push(v);
	while(qq.size()){
		v = qq.front();
		if(bv[v]){
			qq.pop();
			continue;
		}
		qq.pop();
		bv[v] = 1;
		edge tmp;
		for(vector<edge>::iterator i= G[v].begin(); i!=G[v].end(); i++){
			tmp = *i;
			huan[tmp.to] = 1;
			qq.push(tmp.to);
		}
	}
}
void spfa(int s) {
	for(int i=1; i<=n; i++) {
		dis[i] = inf;
		pre[i] = 0;
		inq[i] = 0;
		cnt[i] = 0;
		huan[i] = 0;
		bv[i] = 0;
	}
	dis[s] = 0;
	inq[s] = 1;
	q.push(s);
	while(!q.empty()) {
		int u = q.front();
		q.pop();
		inq[u] = 0;
		for(vector<edge>::iterator i= G[u].begin(); i!=G[u].end(); i++) {
			edge e = *i;
			if(dis[e.to]>(dis[u]+e.w)) {
				int v = e.to;
				cnt[v] = cnt[u] +1;
				if(cnt[v]>=n){
					q = queue<int>();
					huan[v] = true;
					bfs(v);
					break;
				}
				dis[v] = dis[u] + e.w;
				pre[v] = u;
				if(!inq[v]&&!huan[v]) {
					q.push(v);
					inq[v] = 1;
				}
			}
		}	
	}
}
int main() {
//	freopen("in3.txt","r",stdin);
	cin>>t;
	int co = 0;
	while(t) {
		initial();
		t--;
		co++;
		cin>>n;
		for(int i=1; i<=n; i++) {
			scanf("%d",&a[i]);
		}
		cin>>m;
		int ta,tb;
		edge tmp;
		for(int i=1; i<=m; i++) {
			scanf("%d%d",&ta,&tb);
			tmp.to = tb;
			tmp.w = (a[tb]-a[ta])*(a[tb]-a[ta])*(a[tb]-a[ta]);
			G[ta].push_back(tmp);
		}
		spfa(1);
		cin>>pq;
		int tt;
		printf("Case %d:\n",co);
		while(pq){
			pq--;
			scanf("%d",&tt);
			if(!huan[tt]&&dis[tt]!=inf&&dis[tt]>=3) printf("%d\n",dis[tt]);
			else printf("?\n");
		}
	}
	
	return 0;
}