week 7 3种求最短路算法（floyd,dijkstra,spfa）

最新推荐文章于 2021-09-30 19:45:18 发布

活下去

最新推荐文章于 2021-09-30 19:45:18 发布

阅读量105

点赞数

本文链接：https://blog.csdn.net/hexiangqin/article/details/105556992

版权

这里写目录标题

A - TT 的魔法猫
- B - TT 的旅行日记
- - C - TT 的美梦

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

思路：
根据题目的数据范围，利用Floyd算法直接暴力求解，但直接莽会超时，可以进行剪枝。
首先定义一个二维数组，初始化为1，对角线为0；
1表示两者胜负关系未知，0表示已知。
然后利用已有数据进行赋值，将已知的数据赋为0，然后进行3次遍历，两者胜负关系直到的条件为中间会有连通分量，即两个0会比1小，但如果其中一个分量是1，就不必在进行下去，即实现了剪枝。
最后遍历整个数组，找到知道的关系数，即ans，ans2-n即为总共的知道的关系数，然后nn减去他，再/2，既得最终结果。

代码：

#include<iostream>
using namespace std;
int m,n,x,p,q,ans;
int dis[510][510];
int min(int x,int y)
{
	return x<=y?x:y;
}
void floyd()
{
	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<=n;i++)
		{
			if(dis[i][k]==1)
			continue;
			for(int j=1;j<=n;j++)
			{
				dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
			}
		}
	}
}
void clear()
{
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			if(j==i)
			{dis[i][j]=0;
			}
			else
			dis[i][j]=1;
		}
	}
}
int main()
{
	cin >> x;
	while(x--)
	{		
		ans=0;
		cin >> n >> m;
		clear();
		while(m--)
		{
			cin >> p >> q;
			dis[p][q]=0;
		}
		floyd(); 
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				if(dis[i][j]==0)
				ans++;
			}
		}
		//cout << ans << endl;
		cout << n*(n+1)/2-ans << endl;
	}
 }

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 前往喵星机场花费的总时间。

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

输入样例

输出样例

1 2 4
2
5

思路：
对于可以用一张商业票来说，我们可以遍历每张商业票的起始与结束，看这两点起点与终点的距离，加起来再加w，最后与不用商业票进行比较，其中用到Dijkstra算法，利用vis数组进行剪枝，对于输出路径的话，直接在Dijkstra中加入一个前端数组，记录他的前一个值，方便输出路径是进行递归，要顺序输出则print放到最后，要逆序输出则print放前面。

代码：

#include<iostream>
#include<queue>
#include<math.h>
#include<cstring>
using namespace std;
struct edge
{
	int to,next,w;
}e[5050];
int head[550],tot,n,vis[550],flag=0;
int s,E,k,m,a1,a2,a3,par1[550],par2[550],q1,q2;
long long dis1[550],dis2[550],ans=10000000;
void add(int x,int y,int w)
{
	e[++tot].to=y,e[tot].next=head[x];
	e[tot].w=w,head[x]=tot;
}
priority_queue<pair<long long,int> >q;
void dijkstra(int s,long long dis[],int par[])
{
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=n;i++) dis[i]=10000000;
	dis[s]=0;
	par[s]=-1;
	q.push(make_pair(0,s));
	while(!q.empty())
	{
		int x=q.top().second;
		q.pop();
		if(vis[x]) continue;
		vis[x]=1;
		for(int i=head[x];i;i=e[i].next){
			int y=e[i].to,w=e[i].w;
			if(dis[y]>dis[x]+w){
				dis[y]=dis[x]+w;
				q.push(make_pair(-dis[y],y));
				par[y]=x;
			}
		}
	}
}
void print(int s)
{
	if(par1[s]==-1)
	{cout << s;
	return;
	}
	print(par1[s]);
	cout  << " "<< s;
}
void print1(int s)
{
	if(par2[s]==-1)
	{cout << s;
	return;
	}
	cout << s << " ";
	print1(par2[s]);
	
}
int main()
{
	//cout << ans;
	while(scanf("%d%d%d%d",&n,&s,&E,&m)!=EOF)
	{
		
		ans=10000000;
		memset(par1,0,sizeof(par1));
		memset(par2,0,sizeof(par2));
		memset(head,0,sizeof(head));
		memset(e,0,sizeof(edge));
		tot=1; 
	while(m--)
	{
		scanf("%d%d%d",&a1,&a2,&a3);
		add(a1,a2,a3);
		add(a2,a1,a3);
	}
	dijkstra(s,dis1,par1);
	dijkstra(E,dis2,par2);
	//cout << dis1[2] << endl; 
	cin >> k;
	while(k--)
	{
		scanf("%d%d%d",&a1,&a2,&a3);
		if(ans>min(dis1[a1]+dis2[a2]+a3,dis2[a1]+dis1[a2]+a3))
		{
			if(dis1[a1]+dis2[a2]+a3<dis2[a1]+dis1[a2]+a3)
			{ans=dis1[a1]+dis2[a2]+a3;q1=a1,q2=a2;
			}
			else
			{ans=dis2[a1]+dis1[a2]+a3;q1=a2,q2=a1;
			}
			
		}
	}
	//cout << ans << endl;
	//cout << q2 << endl;
	//cout << par2[4] << endl;
	//cout << par2[5] << endl;
	//cout << par2[3] << endl;
	//print1(q2);
	//cout << dis1[E] << endl;
	if(flag!=0)
		cout << endl;
	flag++;
	if(ans<dis1[E])
	{
		print(q1);cout <<" ";print1(q2);
		cout << endl;
		cout << q1 << endl;
		cout << ans << endl;
	}
	else
	{
		print(E);
		cout << endl;
		cout << "Ticket Not Used" << endl;
		cout << dis1[E] << 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算法，利用队列进行优化，如果在这个图中有负环，则某点被松弛的次数一定会超过n次。然后将这个点进行bfs遍历，将其能到达的点进行标记，使得最后输出的置为？，同样bfs可以利用vis数组进行剪枝，而且对于不同的起点可以用同一个vis来剪枝，使得复杂度降低，最后将低于3与属于负环或者不可达作为判断条件，输出？否则就输出dis数组与之对应的值。

代码：

#include<iostream>
#include<list>
#include<queue>
#include<math.h>
#include<cstring>
#define inf 1e8;
using namespace std;
int n,m,a[210],k,l,p,q,t,flag,flagg;
list<int> x[210];
int vis[210],dis[210],cnt[210],visit[210],v[210];
void bfs(int s)
{
	memset(visit,0,sizeof(visit));
	queue<int> z;
	z.push(s);
	visit[s]=1;
	v[s]=1;
	list<int>::iterator it;
	while(!z.empty())
	{
		int now=z.front();z.pop();
		it=x[now].begin();
		while(it!=x[now].end())
		{
			if(visit[*it]==0)
			{
				z.push(*it);
				visit[*it]=1;
				v[s]=1;
			}
			++it;
		}
	}
}
void spfa()
{
	memset(vis,0,sizeof(vis));
	memset(cnt,0,sizeof(cnt));
	for(int i=1;i<=n;i++) dis[i]=inf;
	vis[1]=1;
	dis[1]=0;
	cnt[1]=1;
	queue<int> q;
	q.push(1);
	list<int>::iterator it;
	while(!q.empty())
	{
		int now=q.front();q.pop();
		it=x[now].begin();
		vis[now]=0;
		while(it!=x[now].end())
		{
			if(dis[*it]>dis[now]+pow(a[*it]-a[now],3))
			{
				dis[*it]=dis[now]+pow(a[*it]-a[now],3);
				cnt[*it]++;
				if(cnt[*it]>n)
				{
					bfs(*it);
					continue;
				}
				if(!vis[*it])
				{
					q.push(*it);
					vis[*it]=1;
				}
			}
			++it;
		}
	}
}
void clear()
{
	for(int i=1;i<210;i++)
	x[i].clear();
	memset(a,0,sizeof(a));
	memset(v,0,sizeof(v));
}
int main()
{
	cin >> t;
	for(int g=1;g<=t;g++)
	{
		clear();
		cin >> n;
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
		}
		cin >> m;
		while(m--)
		{
			scanf("%d%d",&k,&l);
			x[k].push_back(l);
		}
		spfa();
		cin >> q;
		cout << "Case "<<g<<":"<< endl;
		while(q--)
		{
			scanf("%d",&p);	
			if(cnt[p]==0||dis[p]<3||v[p]==1)
			cout <<"?" << endl;
			else
			cout << dis[p] << endl;
		}
	}
}

活下去

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
week 7 3种求最短路算法（floyd,dijkstra,spfa）

这里写目录标题A - TT 的魔法猫B - TT 的旅行日记C - TT 的美梦A - TT 的魔法猫众所周知，TT 有一只魔法猫。这一天，TT 正在专心致志地玩《猫和老鼠》游戏，然而比赛还没开始，聪明的魔法猫便告诉了 TT 比赛的最终结果。TT 非常诧异，不仅诧异于他的小猫咪居然会说话，更诧异于这可爱的小不点为何有如此魔力？魔法猫告诉 TT，它其实拥有一张游戏胜负表，上面有 N 个人...
复制链接

扫一扫