用题目来理解floyd与dijkstra【c/c++】

一步步757

已于 2024-07-06 10:23:24 修改

阅读量320

点赞数 1

分类专栏：蓝桥文章标签：算法 c++

于 2023-05-20 23:19:48 首次发布

本文链接：https://blog.csdn.net/weixin_63226758/article/details/130785858

版权

蓝桥专栏收录该内容

2 篇文章 0 订阅

订阅专栏

题目适合新手练习图论内容，这里用floyd,dijkstra算法就解决这道题，并且给出思路，以及需要注意的点。

题目描述

小明喜欢观景，于是今天他来到了蓝桥公园。已知公园有 N 个景点，景点和景点之间一共有 M 条道路。小明有Q个观景计划，每个计划包含一个起点 st 和一个终点 ed，表示他想从 st 去到 ed。但是小明的体力有限，对于每个计划他想走最少的路完成，你可以帮帮他吗?
输入描述

输入第一行包含三个正整数N，M，Q

第2到M+1行每行包含三个正整数u,v,w,表示u<—>v之间存在一条距离为w的路。

第M+2到M+Q-1行每行包含两个正整数st,ed,其含义如题所述

输出描述

输出共Q行，对应输入数据的查询。

若无法从st到达ed则输出-1

样例

输入

输出

1
3
2

方法一：floyd

floyd算法介绍：Floyd算法，也称为Floyd-Warshall算法，是一种用于寻找图中最短路径的算法。它可以处理带有负边权的图，时间复杂度为O(n^3)。Floyd算法适用于所有的有向图，但是不适用于带有负环的图。它的基本思想是动态规划，通过计算出所有点之间的最短路径，来得到整张图的最短路径。具体实现时，需要用一个二维数组来存储任意两个顶点之间的最短路径长度，再根据这个数组来计算最短路径。

#include<bits/stdc++.h>//floyd
using namespace std;
#define int long long//将所有的int 替换成long long 注意main函数要设置成signed类型
typedef long long ll;//将long long 作为（as） ll
ll N;
ll dp[405][405];//dp[u][v]=w ,包括了信息u道路到v道路的距离为w
void floyd(int n){ //floyd算法主体
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			for(int k=1;k<=n;k++){
//				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]); 无法松弛i->k->k-1->j ,(i->k-1不通); 
				dp[j][k]=min(dp[j][k],dp[j][i]+dp[i][k]);//用i松弛j<->k
			}
		}
	}
}
signed main(void){
	ll M,Q; 
	cin>>N>>M>>Q;
	ll inf=1e15;//设置最大最小值还存在疑问 
	memset(dp,0x3f,sizeof dp);//初始化dp
	for(int i=0;i<M;i++){
		ll u,v,w;
		cin>>u>>v>>w;
		dp[u][v]=dp[v][u]=min(dp[u][v],w);//无向图，并且找出u<-->v的最小值
	}
	for(int i=1;i<=N;i++){
		dp[i][i]=0;//自己到自己距离为零
	}
	floyd(N);
	while(Q--){
		int st,ed;
		cin>>st>>ed;
		if(dp[st][ed]>inf) cout<<-1<<'\n';
		else cout<<dp[st][ed]<<'\n';
	}

	return 0;
}

算法主要思路是用一个点不断的去松弛其他的点，该代码中用i去松弛其他各点

Floyd算法的时间复杂度为O(n^3)，适用于顶点数较少，但边数较多的图。

方法二:dijkstra

dijkstra算法介绍：Dijkstra算法是一种用于寻找图中单源最短路径的贪心算法，其时间复杂度为O(E + VlogV)，其中E为边数，V为顶点数。它的基本思想是从起点开始，找到到所有其他顶点的最短路径，并标记已经找过的顶点，然后根据已找到的最短路径，选择下一个最短路径未知的顶点，不断递推下去，直到所有顶点都被标记或者找到了到达终点的最短路径。具体实现时，需要用一个数组来存储起点到每个顶点的最短路径和一个集合来存储已经找到最短路径的顶点，同时需要使用优先队列来选择下一个最短路径未知的顶点。对于边权为负数的图，Dijkstra算法是不适用的，因为它会陷入无限循环。

#include<bits/stdc++.h> 
#define int long long
using namespace std;
int st,ed,N,inf;
int dp[405][405];
long long w[405];
void dijkstra(){
	memset(w,0,sizeof(w));//初始化全为零
	int M1=N-1; 
	while(M1--){
		long long number=inf,flag=-1;
		for(int i=1;i<=N;i++){
			if(!w[i])
			if(number>dp[st][i]||flag==-1){
				number=dp[st][i];//找到最小值
				flag=i;
			}
		}
		w[flag]=1;
		for(int i=1;i<=N;i++){
			dp[st][i]=min(dp[st][i],dp[st][flag]+dp[flag][i]);//路径长度更新
		}
	}
	return ;
}
signed main(void){
	int M,Q;
	cin>>N>>M>>Q;
	memset(dp,0x3f3f,sizeof dp);//初始化
	inf=dp[0][0];//让inf=dp[0][0],使得最大值inf不存在路径是一致的
	for(int i=0;i<M;i++){
		int u,v,w;
		cin>>u>>v>>w;
		dp[u][v]=dp[v][u]=min(dp[u][v],w);
	}
	for(int i=1;i<=N;i++){
		dp[i][i]=0;
	}
     for(int i=0;i<Q;i++){
     	cin>>st>>ed;
     	dijkstra(); 
		if(dp[st][ed]>=inf) cout<<-1<<'\n';
		else cout<<dp[st][ed]<<'\n';   	
	 }	
	return 0;
}

dijkstra算法的主要思想：从起点开始，不断地找到到达离起点(st)最近的尚未访问过的节点，

循环一遍，找到最近的那个节点，该节点离起点最近，无论如何松弛都不可能更近，于是用该节点去松弛其他节点，直到最后一个未访问的节点。

有什么问题私信或者评论

题目来自蓝桥官网