week7--图的最短路径问题

最新推荐文章于 2024-04-28 10:50:33 发布

✘万里长梦

最新推荐文章于 2024-04-28 10:50:33 发布

阅读量244

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/qq_45029327/article/details/105299830

版权

week7

A题
B题
C题

A题

Floyd算法

在解决最短路径的时候我们会学习到Floyd算法，如何理解这个算法呢？
用dis[i][j]来记录点i到点j的最短路径，
可以用下面的式子更新dis[i][j]:
dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j])。也就是通过点k的路径是否更短。
在这里插入图片描述
Floyd算法的代码实现：时间复杂度是O(n^3)

void floyd(int n，int **dis)
{
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				dis[i][j]=std::min(dis[i][j],dis[i][k]+dis[k][j]);
}

题目1：

众所周知，TT 有一只魔法猫。

这一天，TT 正在专心致志地玩《猫和老鼠》游戏，然而比赛还没开始，聪明的魔法猫便告诉了 TT 比赛的最终结果。TT 非常诧异，不仅诧异于他的小猫咪居然会说话，更诧异于这可爱的小不点为何有如此魔力？

魔法猫告诉 TT，它其实拥有一张游戏胜负表，上面有 N 个人以及 M 个胜负关系，每个胜负关系为 A B，表示 A 能胜过 B，且胜负关系具有传递性。即 A 胜过 B，B 胜过 C，则 A 也能胜过 C。

TT 不相信他的小猫咪什么比赛都能预测，因此他想知道有多少对选手的胜负无法预先得知，你能帮帮他吗？

分析

这个题其实就可用Floyd算法来实现，相比于用Floyd算法求两点之间的最短路径。这道题目其实要求的是两点之间是否有路径？
对Floyd算法进行改进一下：
dis[i][j]=1，则i，j之间胜负知道；
dis[i][j]=0，则i，j之间不知道胜负。

void floyd(int n，int **dis)
{
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				dis[i][j]=std::max(dis[i][j],dis[i][k]&dis[k][j]);
}

注意
如果直接这样提交的话，会超时，这里可以在Floyd算法里面进行剪枝。分析一下，发现第二层循环的时候，如果dis[i][k]=0，表示i到k之间就没有路径，更不要说过点k会有一条i到j的路径。
所以，改进一下是：

	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]=std::max(dis[i][j],dis[i][k]&dis[k][j]);
		}

所有代码

#include<stdio.h>
#include<algorithm>
using namespace std;
int dis[502][502];
void floyd(int n)
{
	int sum_count=n*(n-1)/2,count=0;
	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]=std::max(dis[i][j],dis[i][k]&dis[k][j]);
			}
		}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			if(dis[i][j]==1)
			{
				count++;
			}
	printf("%d\n",sum_count-count);
}
int main()
{
	int c,n,m;
	scanf("%d",&c);
	for(int i=0;i<c;i++)
	{
		int A,B;
		scanf("%d %d",&n,&m);
		for(int k=0;k<=n;k++)
			for(int j=0;j<=n;j++)
				dis[k][j]=0;
		for(int j=0;j<m;j++)
		{
			scanf("%d %d",&A,&B);//A B的胜负
			dis[A][B]=1;
		}
		floyd(n);
	}
	return 0;
}

B题

Dijkstra算法

这个算法适用于没有负边的单源最短路径问题；
大概流程：
1、设置s为源点，dis【a】表示s到a的最短距离；初始化dis[s]=0, dis[i]=inf, 将s加入最小堆
2、每次从堆中取出点x，遍历点x所有邻接的边（x,y,w），比较dis[y] 和dis[x]+w的大小
3、松弛操作：
如果dis[y]>dis[x]+w ,就更新dis[y]=dis[x]+w，并将y加入最小堆中
4、重复上面的操作，直到最小堆为空
代码： 在这里插入图片描述 ma一下~

这里用的是最大堆模拟最小堆（添加一个负号即可）

题目

众所周知，TT 有一只魔法猫。

今天他在 B 站上开启了一次旅行直播，记录他与魔法猫在喵星旅游时的奇遇。 TT 从家里出发，准备乘坐猫猫快线前往喵星机场。猫猫快线分为经济线和商业线两种，它们的速度与价钱都不同。当然啦，商业线要比经济线贵，TT 平常只能坐经济线，但是今天 TT 的魔法猫变出了一张商业线车票，可以坐一站商业线。假设 TT 换乘的时间忽略不计，请你帮 TT 找到一条去喵星机场最快的线路，不然就要误机了！

分析

1、首先做两次dijkstra，分别从源点S和终点E出发，到各点的距离用dis1，dis2数组记录；
2、遍历每一个商业线x,y,z，计算加上商业线的最短路径：
d1=dis1[x]+dis2[y]+z;
d2=dis1[y]+dis2[x]+z;
d1、d2当中最小的是经过这个商业线的最短路径
3、比较商业线中的最短路径，和不加上商业线的最短路径，判断选取哪条线。

在这里可以这样遍历商业线，是因为商业线只能乘坐一次。

代码

#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;
const int inf =5*1e8;
struct edge{
	int to,next,w;
}e[5000];//前向星
int head[5000],tot,n,vis[5000];
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<int,int>> q;
void dijkstra(int s,int *dis,int *pre)
{
	while(q.size()) q.pop();
	for(int i=0;i<5000;i++) vis[i]=0;
	for(int i=1;i<=n;i++) dis[i]=inf;
	dis[s]=0;pre[s]=0;
	q.push(make_pair(0,s));
	while(q.size())
	{
		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)
			{
				pre[y]=x;
				dis[y]=dis[x]+w;
				q.push(make_pair(-dis[y],y));
			}
		}
	}
}
void outputS(int x,int S,int *pre1)
{
	if (x == S)
	{
		printf("%d", x);
		return;
	}
	outputS(pre1[x],S,pre1);
	printf(" %d", x);
}
void outputE(int x,int E,int *pre2)
{
	while (x != E)
	{
		printf(" %d", x);
		x = pre2[x];
	}
	printf(" %d", x);
}

int main()
{
	int S,E,M,K,tmin=inf,dis1[5000],dis2[5000],pre1[5000],pre2[5000];
	int x,y,z,u,v;
	int flag=0;
	while(~scanf("%d %d %d",&n,&S,&E))
	{
		if(flag!=0) printf("\n");
		for(int i=0;i<5000;i++){
			pre1[i]=0;pre2[i]=0;head[i]=0;tot=0;tmin=inf;
		}
		scanf("%d",&M);
		while(M!=0)
		{
			scanf("%d %d %d",&x,&y,&z);
			add(x,y,z);
			add(y,x,z);
			M--;
		}
		scanf("%d",&K);
		dijkstra(S,dis1,pre1);
		dijkstra(E,dis2,pre2);
		for(int i=0;i<K;i++)
		{
			scanf("%d %d %d",&x,&y,&z);
			int d1=dis1[x]+dis2[y]+z;
			int d2=dis1[y]+dis2[x]+z;
			if(d1<tmin){
				tmin=d1; u=x;v=y;
			}
			else if(d2<tmin){
				tmin=d2; u=y;v=x;
			}
		}
		
		if(tmin>dis1[E])
		{
			tmin=dis1[E];
			//不要商业线
			outputS(E,S,pre1);
			printf("\nTicket Not Used\n");
			printf("%d\n",tmin);
		}
		else
		{
			outputS(u,S,pre1);outputE(v,E,pre2);
			printf("\n%d\n",u);
			printf("%d\n",tmin);
		}
		flag++;
	}
	return 0;
}

C题

bellman算法和SPFA

bellman算法就是多轮松弛的过程，第一轮松弛确定第一条边…
但是这样的算法复杂度很高O(nm)
所以提出了队列优化的算法SPFA算法：
1、建立一个队列，队列中存储成功被松弛的点
2、每次从队首取出一点，并松弛其邻接点
3、如果临界点成功松弛就放入队列中（防止重复入队，用一个数组inq记录是否已经入队）

什么时候最短路不存在
1、S不可达，即如果u到S不可达dis[u]=inf
2、图中存在负环；如果存在负环，那么最短路经过的边数会>=n
对于这种情况，用一个dfs对负环上的边打上标记，表示这个也是不存在最短路的。
算法代码：

void dfs(int x){//用dfs打标记
	dis[x]=-inf;
	for(int i=head[x];i!=0;i=e[i].next){
		if(dis[e[i].to]!=-inf){
			dfs(e[i].to);
		}
	}
}

void SPFA(int s){
	while(q.empty()==0){q.pop();}
	dis[s]=0;inq[s]=1;//防止重复入队
	q.push(s);
	while(!q.empty()){
		int u=q.front();q.pop();
		inq[u]=0;
		if(dis[u]==-inf){continue;}
		for(int i=head[u];i!=0;i=e[i].next){
			int v=e[i].to;
			if(dis[v]>dis[u]+e[i].w){
				cnt[v]=cnt[u]+1;
				if(cnt[v]>=N){//有负环
					dfs(v);//标记
				}
				dis[v]=dis[u]+e[i].w;pre[v]=u;
				if(!inq[v]&&dis[v]!=-inf){
					q.push(v);inq[v]=1;
				}
			}
		}
	}
}

题目

这一晚，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 则输出 ‘?’。

分析

因为（目的地繁荣程度 - 出发地繁荣程度）^ 3 是权重，明显地，这个权重可能是负数，所以想到使用SPFA算法

代码

#include<stdio.h>
#include<queue>
#include<math.h>
using namespace std;
const int inf=1e7;

int T,N,M,A,B,Q,P,tot;
int a[205];//点的权值
int head[205],inq[205],dis[205],cnt[205],pre[205];
queue<int> q;

struct edge{
	int to,next,w;
}e[100005];
void add(int x,int y)
{
	e[++tot].to=y;
	e[tot].next=head[x];
	head[x]=tot;
	e[tot].w=pow(a[y]-a[x],3);
}

void dfs(int x){
	dis[x]=-inf;
	for(int i=head[x];i!=0;i=e[i].next){
		if(dis[e[i].to]!=-inf){
			dfs(e[i].to);
		}
	}
}

void SPFA(int s){
	while(q.empty()==0){q.pop();}
	dis[s]=0;
	inq[s]=1;
	q.push(s);
	while(!q.empty()){
		int u=q.front();q.pop();
		inq[u]=0;
		if(dis[u]==-inf){continue;}
		for(int i=head[u];i!=0;i=e[i].next){
			int v=e[i].to;
			if(dis[v]>dis[u]+e[i].w){
				cnt[v]=cnt[u]+1;
				if(cnt[v]>=N){
					//找到负环
					dfs(v);//标记
				}
				dis[v]=dis[u]+e[i].w;
				pre[v]=u;
				if(!inq[v]&&dis[v]!=-inf){
					q.push(v);
					inq[v]=1;
				}
			}
		}
	}
}

int main(){
	scanf("%d",&T);
	for(int i=1;i<=T;i++){
		tot=0;
		for(int i=1;i<=205;i++){
			head[i]=0;inq[i]=0;dis[i]=inf;cnt[i]=0;pre[i]=0;
		}
		scanf("%d",&N);//点的个数
		for(int j=1;j<=N;j++){
			scanf("%d",&a[j]);
		}
		scanf("%d",&M);//有向道路的条数
		for(int j=1;j<=M;j++){
			scanf("%d %d",&A,&B);
			add(A,B);
		}
		SPFA(1);
		scanf("%d",&Q);
		printf("Case %d:\n",i);
		for(int j=1;j<=Q;j++){
			scanf("%d",&P);
			if(dis[P]<3||dis[P]==inf){
				printf("?\n");
			}
			else{printf("%d\n",dis[P]);	}
		}
	}
}

✘万里长梦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
week7--图的最短路径问题

Floyd算法在解决最短路径的时候我们会学习到Floyd算法，如何理解这个算法呢？用dis[i][j]来记录点i到点j的最短路径，可以用下面的式子更新dis[i][j]:dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j])。也就是通过点k的路径是否更短。Floyd算法的代码实现：时间复杂度是O(n^3)void floyd(int n，int **...
复制链接

扫一扫