week7-作业

最新推荐文章于 2022-05-29 19:11:58 发布

Rainbow-c

最新推荐文章于 2022-05-29 19:11:58 发布

阅读量431

点赞数

分类专栏：程序设计

本文链接：https://blog.csdn.net/qq_43746837/article/details/105381600

版权

程序设计专栏收录该内容

43 篇文章 0 订阅

订阅专栏

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：

Sample Output：

0
0
4

题目分析：

该题题意简述为：已知N个人，M个胜负关系，每个关系A,B,表示A比B强，且胜负关系具有传递性，求多少场比赛的胜负无法预先得知。

由1≤𝑁,𝑀≤500的数据规模可以得知本题要求复杂度为 𝑂(𝑛3) 并且因为胜负关系具有传递性，因此可以用 Floyd算法求出任意两点的胜负关系（传递闭包）。 Floyd–Warshall 算法用于求取图中任意两点之间的关系，对于多源最短路，可以求出任意两点的距离关系，对于图上的传递闭包，可以求出任意两点的连通关系。
首先对于输入的M个胜负关系，相应的dis[a][b]置为1，表示胜负关系已知且a比b强；然后对N个人(相当于N个顶点，遍历dis数组，令dis[i][j] = max(dis[i][j], dis[i][k]& dis[k][j]);得出新的dis值。
（注意，为了降低时间复杂度，需要进行Floyd的剪枝，即加上判断if(dis[i][k]!=0)再进行dis的判断更新，因为(dis[i][k]==0)的时候，逻辑与操作结果一定为0，即无需更新）
最后对Floyd之后的dis进行遍历
•dis[a][b]=1;表示 a 比 b 强；
•dis[a][b]=0；表示 a 与 b 的胜负关系不明；
•dis[a][b]=0且dis[a][b]=0；表示a与b的胜负关系无法预先判断。因为两个方向都不明确的话无法判断两者之间的胜负关系。
找出所有的dis[a][b]=0且dis[a][b]=0的情况，并计数，最后输出计数结果即为最终的不能得出胜负关系的数目。

代码：

#include<iostream>
#include<stdio.h>
#include<string.h> 
#include<algorithm>
using namespace std;
const int maxn=5e2+5;
int dis[maxn][maxn];

void Floyd(int n)
{
	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<=n;i++)
		{
			if(dis[i][k]!=0)
			{
				for(int j=1;j<=n;j++)
				{
					dis[i][j] = max(dis[i][j], dis[i][k]& dis[k][j]);
				}	
			}
		}
	}
}
int main()
{
	int x;
	scanf("%d",&x); 
	while(x--)
	{	
		int n,m;
		memset(dis,0,sizeof(dis));
		int ans;
		ans=0;
		scanf("%d%d",&n,&m);//n个人，m个胜负关系 
		for(int i=0;i<m;i++)
		{
			int a,b;
			scanf("%d%d",&a,&b);//表示a>b； 
			dis[a][b]=1;
		}
		Floyd(n);
		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 找到一条去喵星机场最快的线路，不然就要误机了！

Input：

输入包含多组数据。每组数据第一行为 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 行是商业线路段的描述，格式同经济线。
所有路段都是双向的，但有可能必须使用商业车票才能到达机场。保证最优解唯一。

Output：

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

Sample Input：

Sample Output：

1 2 4
2
5

题目分析：

题目给定了起点与终点，而且要求商业线最多乘坐一次，所以可以枚举每一条商业线，计算起点到u的最短路以及v到终点的最短路再加上该商业线所花费的时间，即为最终的从起点到终点喵星机场的时间花费。

• 以起点为源点求单源最短路，得到 dis1 数组；
• 再以终点为源点求单源最短路，得到 dis2 数组；
• 枚举商业线(u, v, w)，取 min{dis1[u]+dis2[v]+w, dis1[v]+dis2[u]+w}，最终再与不走商业线的答案取min。
首先对于经济线的各线路，用前向星数组双向存储，而后分别以起点和终点为原点进行dijkstra单源最短路求解，分别得到dis1，pre1，dis2，pre2数组，其中dis为从起点到终点的时间，pre为前节点的记录数组；
然后枚举每一条商业线，计算起点到u的最短路以及v到终点的最短路再加上该商业线所花费的时间，及时更新最短时间花费，并在更新后记录商业线的左右端点，（左端点即为换乘车站编号）；
最后分为经过商业街和不经过商业街（dis1[E]<=ans ）两种情况进行判断输出最终结果，这里的输出是一种对pre数组的递归输出，当不经过商业街时，递归输出pre1[]数组，直到点为起点终止；当经过商业街时，对商业街的左端点递归输出pre1[]数组，直到起点，对商业街的右端点，递归输出pre2[]数组，直到终点。

（每一组答案间要输出一个换行）
（输出不能像下面这样直接用中间数组输出，会报runtime error！！）
在这里插入图片描述

代码：

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int maxn=2e3+5;
const int inf=1e8;
struct edge
{
	int to,next,w;
}e[maxn];
int head[maxn],tol,vis[maxn];
int dis1[maxn],dis2[maxn];// 分别为以起点为源点和以终点为原点求单源最短路 
int pre1[maxn],pre2[maxn];//记录经过的各个车站
int nxt[maxn];
int N,S,E;//车站总数，起点，终点
void addedge(int x,int y,int w)//前向星存储图结构 
{
	e[++tol].to=y;
	e[tol].w=w;
	e[tol].next=head[x];
	head[x]=tol;	
}	
priority_queue<pair<int,int> > q;//最大堆
void dijkstra(int s,int dis[],int pre[])//dijkstra单源最短路径 
{	
	while(q.size()) q.pop();
	
	dis[s]=0;
	q.push(make_pair(0,s));
	while(!q.empty()) 
	{
		int temp=q.top().second;//堆顶最小元素 
		q.pop();
		if(vis[temp])//每条边只弹出一次 
		{
			continue;
		}
		vis[temp]=1;
		for(int i=head[temp];i;i=e[i].next)
		{
			int y=e[i].to;
			int w=e[i].w;
			if(dis[y]>dis[temp]+w)//松弛 
			{
				dis[y]=dis[temp]+w;
				q.push(make_pair(-dis[y],y));
				pre[y]=temp; //记录前节点 
			}
		}
	}
	 
}
void output1(int s)
{
	if(s!=S)
	{
		output1(pre1[s]);
	}
	if(s==S)printf("%d",s);
	else
	{
		printf(" %d",s);
	}
}
void output2(int e)
{
	while(e!=E)
	{
		printf(" %d",e);
		e=pre2[e];
	}
	printf(" %d",e);
}
int main()
{
	int num=0;
	while(scanf("%d%d%d",&N,&S,&E)!=EOF)
	{	
		if(num>0)
		{
			printf("\n");
		}num++;
		int trans=0;//记录换乘商业线的车站编号 
		int m;//经济线的路段条数
		scanf("%d",&m);
		tol=0;
		memset(head,0,sizeof(head)); 
		memset(nxt,0,sizeof(nxt));
		
		for(int i=0;i<m;i++)
		{
			int x,y,z;//可以乘坐经济线在车站 X 和车站 Y 之间往返，其中单程需要 Z 分钟。
			scanf("%d%d%d",&x,&y,&z);
			addedge(x,y,z);
			addedge(y,x,z);
		}
		memset(vis,0,sizeof(vis));
		memset(dis1,0x3f,sizeof(dis1));
		memset(pre1,-1,sizeof(pre1));
		
		dijkstra(S,dis1,pre1);
		
		memset(vis,0,sizeof(vis));
		memset(dis2,0x3f,sizeof(dis2));
		memset(pre2,-1,sizeof(pre2));
		
		dijkstra(E,dis2,pre2);
		
		int k;//商业线的路段条数 
		scanf("%d",&k);
		int ans=dis1[E];
		//cout<<"***"<<ans<<endl;
		int l=0,r=0;
		for(int i=0;i<k;i++)//经过商业街 找出当前最短路径 
		{
			int x,y,z;
			scanf("%d%d%d",&x,&y,&z);  
			int temp1=dis1[x]+dis2[y]+z;
			int temp2=dis1[y]+dis2[x]+z; 
			if( ans>temp1 )
			{
				ans=temp1;
				trans=x;
				l=x;r=y;
			}
			if( ans>temp2)
			{
				ans=temp2;
				trans=y;
				l=y;r=x;
			}	
		}
 
		int kk=0;
		if(dis1[E]<=ans)//不经过商业街 （从起点单源路径小于经过商业街） 
		{
			output1(E); 
			printf("\n");
			printf("Ticket Not Used\n");
			printf("%d\n",dis1[E]);
		} 
		else
		{	
			output1(l);
			output2(r);
			printf("\n");
			printf("%d\n",trans);
			printf("%d\n",ans);
		}	
	} 
	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:
?
?

题目分析：

题目要求从1 号点到p号点的最少税费，相当于求1 到其他点的最短路。因为税费=（目的地繁荣程度 - 出发地繁荣程度）^ 3，所以当目的地繁荣程度小于出发地繁荣程度时会出现税费为负的情况，即图中存在负权边，这是一个含负权边的单源最短路径问题。所以考虑SPFA（Shortest Path Faster Algorithm）算法。
建立一个队列，队列中存储被成功松弛的点，每次从队首取点并松弛其邻接点，如果邻接点成功松弛则将其放入队列，并记录已经放入队列的边的数目，当边的数目大于等于n的时候，说明出现了负环，对那些通过负环可以到达的所有点经过dfs全部标记。
对每一个要查询的p号点，判断是否可达，当从一号点到p号点的最短消耗dis[p]==inf不存在最短路或者经过负环fuhuan[p] 时不可达，当dis[p]<3时,税费小于3，以上情况均输出？；否则的话输出dis[p]消耗的税费即可。

（注意输出格式！！）

代码:

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<queue>
#include<string.h>
using namespace std;
const int maxn=1e5+5;
const int inf=1e8+10;
struct edge
{
	int to,w,next;
}e[maxn];
int head[maxn],tol;
void addedge(int u,int v,int w)
{
	e[++tol].to=v;
	e[tol].w=w;
	e[tol].next=head[u];
	head[u]=tol;
	
}
int vis[maxn],cnt[maxn],dis[maxn];
bool fuhuan[maxn];
void dfs(int s)//找到负环后，将负环所在连通块里的点打上标记
{
	for(int i=head[s];i;i=e[i].next)
	{
		int y=e[i].to;
		if(!fuhuan[y])
		{
			fuhuan[y]=1;
			dfs(y);
		}
	}
}
void spfa(int s,int n)
{
	queue<int> q;
	for(int i=1;i<=n;i++)
	{
		vis[i]=cnt[i]=fuhuan[i]=0;
		dis[i]=inf;
	}
	dis[s]=0;
	q.push(s);//队列加入起始点 
	vis[s]=1;
	while(!q.empty())
	{
		int temp=q.front();
		q.pop();
		vis[temp]=0;//temp出了队列，vis=0
		for(int i=head[temp];i;i=e[i].next)
		{
			int y=e[i].to;
			int w=e[i].w;
			if(dis[y]>dis[temp]+w)
			{
				dis[y]=dis[temp]+w;
				cnt[y]=cnt[temp]+1;//边数加1
				if(cnt[y]>=n)//找到负环 
				{
					dfs(y);
					continue;
				} 
				if(!vis[y])
				{
					q.push(y);
					vis[y]=1;
				 } 
			}
		} 
	}
	
}
int main()
{
	int T;
	scanf("%d",&T);
	int d=T;
	while(T--)
	{
		int n;//点的个数
		scanf("%d",&n);
		int *a=new int[n+1];
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
		}
		int m;
		scanf("%d",&m);//表示有向道路的条数
		tol=0;
		memset(head,0,sizeof(head));
		for(int i=0;i<m;i++)
		{
			int b,c;
			scanf("%d%d",&b,&c);//表示存在一条 A 到 B 的有向道路。
		//	int we=(a[c]-a[b]) *(a[c]-a[b]) *(a[c]-a[b]);
			addedge(b,c,pow(a[c]-a[b],3));
		}
		spfa(1,n);
		int Q;//表示询问个数
		scanf("%d",&Q);
		
		printf("Case %d:\n",d-T);
		for(int i=0;i<Q;i++)
		{
			int p;
			scanf("%d",&p);//表示求 1 号点到 P 号点的最少税费
			if(dis[p]==inf || fuhuan[p] || dis[p]<3)//不可达或税费小于 3
			{
				printf("?\n");
			}
			else
			{
				printf("%d\n",dis[p]);
			}
		}	
	}
	return 0;
}