最短路

最新推荐文章于 2023-10-07 16:27:02 发布
最新推荐文章于 2023-10-07 16:27:02 发布
阅读量394 收藏
点赞数 1
分类专栏： # 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43640009/article/details/104399732
版权

目录

参考了这篇最短路问题–最通俗易懂的讲解和《挑战程序设计竞赛》

最短路径是指：
如果从图中某一顶点（源点）到达另一顶点（终点）的路径可能不止一条，如何
找到一条路径使得沿此路径上各边的权值总和（称为路径长度）达到最小。
在这里插入图片描述

单源最短路问题

固定一个起点，求它到其他所有点的最短路的问题。
终点也固定的问题叫做两点间最短路问题，通常当做单源最短路求解。

Dijkstra算法（边权值非负）

基于贪心策略的思想，算法是按路径长度从小到大的顺序一步一步并入来求取，用来解决单源点到其余顶点的最短路径问题。
时间复杂度O(N^2)，堆优化后时间复杂度O(nlogn)。

即：从剩余路径中找最短的路径，然后更新最短路径。
d[ i ] = min { d[ j ] + (j -> i 边权值) | e=(j,i)∈E}

邻接矩阵形式，时间复杂度为O(V^2)

#define INF 0x3f3f3f3f
const int maxn=1010;
int cost[maxn][maxn];
int d[maxn];  
bool vis[maxn];
int n;

void dijkstra(int s){
	fill(d,d+n,INF);
	fill(vis,vis+n,false);
	d[s]=0;
	while (1){
		int k=-1;
		for (int i=0; i<n; i++){
			if (!vis[i] && (k==-1 || d[i]<d[k]))
				k=i;
		}
		if (k==-1) break;
		vis[k]=true;
		for (int i=0; i<n; i++){
			d[i]=min(d[i],d[i]+cost[k][i]);
		}
	}
}

优先队列优化，时间复杂度O(E*logV)

#define INF 0x3f3f3f3f
typedef pair<int, int> P; //first：最短距离 second：顶点编号
struct edge {
	int to,cost;
};

const int maxn=1010;
int n;
vector <edge> G[maxn];
int d[maxn];

void dijkstra(int s) {
	//堆按照first从小到大顺序取出值
	priority_queue<P, vector<P>, greater<P> > que;
	fill(d,d+n,INF);
	d[s]=0;
	que.push(P(0, s));
	while (!que.empty()) {
		P p=que.top();
		que.pop();
		int v=p.second;
		if (d[v]<p.first) continue;
		for (int i=0; i<G[v].size(); i++) {
			edge e=G[v][i];
			if (d[e.to]>d[v]+e.cost) {
				d[e.to]=d[v]+e.cost;
				que.push(P(d[e.to], e.to));
			}
		}
	}
}

/*void addedge(int u,int v, int w) {
	G[u].push_back({v,w});
}*/ //这样写会warning，C++11可用

void addedge(int u,int v, int w){
	edge t;
	t.to=v;
	t.cost=w;
	G[u].push_back(t);
}
POJ2387
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;

int n;
#define INF 0x3f3f3f3f
typedef pair<int, int> P; //first：最短距离 second：顶点编号
struct edge {
	int to,cost;
};

const int maxn=1010;
vector <edge> G[maxn];
int d[maxn];

void dijkstra(int s) {
	//堆按照first从小到大顺序取出值
	priority_queue<P, vector<P>, greater<P> > que;
	fill(d+1,d+n+1,INF);
	d[s]=0;
	que.push(P(0, s));
	while (!que.empty()) {
		P p=que.top();
		que.pop();
		int v=p.second;
		if (d[v]<p.first) continue;
		for (int i=0; i<G[v].size(); i++) {
			edge e=G[v][i];
			if (d[e.to]>d[v]+e.cost) {
				d[e.to]=d[v]+e.cost;
				que.push(P(d[e.to], e.to));
			}
		}
	}
}

void addedge(int u,int v, int w){
	edge t;
	t.to=v;
	t.cost=w;
	G[u].push_back(t);
}


int main() {

	ios::sync_with_stdio(0);
	cin.tie(0);
	int T;
	while (cin>>T>>n) {
		while (T--) {
			int a,b,x;
			cin>>a>>b>>x;
			addedge(a,b,x);
			addedge(b,a,x);

		}
		dijkstra(n);
		cout<<d[1]<<endl;
	}

	return 0;
}
Bellman-Ford算法（有负边）

时间复杂度 O(VE)

#define INF 0x3f3f3f3f
struct edge {
	int from,to,cost;
};

const int maxn=550;
vector <edge> E;
int d[maxn];
int n,m; //n：V个数 m：E个数=E.size()

bool bellman_ford(int s) {
	fill(d,d+n,INF);
	d[s]=0;
	for (int i=0; i<n; i++) {
		bool flag=false;
		for (int j=0; j<m; j++) {
			int u=E[j].from;
			int v=E[j].to;
			int cost=E[j].cost;
			if (d[v]>d[u]+cost) {
				d[v]=d[u]+cost;
				flag=true;
			}
		}
		if (!flag) return true; //没有负环回路
	}
	for (int j=0; j<m; j++) {
		if (d[E[j].to]>d[E[j].from]+E[j].cost)
			return false; //有负环回路
	}
	return true; //没有负环回路
}

void addedge(int u,int v, int w){
	edge t;
	t.from=u;
	t.to=v;
	t.cost=w;
	E.push_back(t);
}
SPFA算法

Spfa就是使用队列或者栈的Bellman-Ford算法的优化版本
时间复杂度 O(kE)

在这里插入图片描述

#define INF 0x3f3f3f3f
const int maxn=1010;

struct edge {
	int to,cost;
};

vector <edge> E[maxn];
bool vis[maxn];
int cnt[maxn]; //每个点入队列次数
int d[maxn];
int n;

bool spfa(int s) {
	fill(vis,vis+n,false);
	fill(d,d+n,INF);
	vis[s]=true;
	d[s]=0;
	queue <int> que;
	while(!que.empty()) que.pop(); 
	que.push(s);
	memset(cnt,0,sizeof(cnt));
	cnt[s]=1;
	while (!que.empty()){
		int u=que.front();
		que.pop();
		vis[u]=false;
		for (int j=0; j<E[u].size(); j++){
			int v=E[u][j].to;
			if (d[v]>d[u]+E[u][j].cost){
				d[v]=d[u]+E[u][j].cost;
				if (!vis[v]){
					vis[v]=true;
					que.push(v);
					if (++cnt[v]>n) return false;
				}
			}
		}
	}
	return true;
}

void addedge(int u,int v, int w){
	edge t;
	t.to=v;
	t.cost=w;
	E[u].push_back(t);
}
POJ3259
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
#define INF 0x3f3f3f3f
const int maxn=2550;

struct edge {
	int to,cost;
};

vector <edge> E[maxn];
bool vis[maxn];
int cnt[maxn]; //每个点入队列次数
int d[maxn];
int n,m,w;

bool spfa(int s) {
	fill(vis,vis+n,false);
	fill(d+1,d+n+1,INF);
	vis[s]=true;
	d[s]=0;
	queue <int> que;
	while(!que.empty()) que.pop();
	que.push(s);
	memset(cnt,0,sizeof(cnt));
	cnt[s]=1;
	while (!que.empty()) {
		int u=que.front();
		que.pop();
		vis[u]=false;
		for (int j=0; j<E[u].size(); j++) {
			int v=E[u][j].to;
			if (d[v]>d[u]+E[u][j].cost) {
				d[v]=d[u]+E[u][j].cost;
				if (!vis[v]) {
					vis[v]=true;
					que.push(v);
					if (++cnt[v]>n) return false;
				}
			}
		}
	}
	return true;
}

void addedge(int u,int v, int w) {
	edge t;
	t.to=v;
	t.cost=w;
	E[u].push_back(t);
}

int main() {

	ios::sync_with_stdio(0);
	cin.tie(0);
	int T;
	cin>>T;
	int s,e,t;
	while (T--) {
		for (int i=0; i<=n; i++) E[i].clear();
		cin>>n>>m>>w;
		while (m--) {
			cin>>s>>e>>t;
			addedge(s,e,t);
			addedge(e,s,t);
		}
		while (w--) {
			cin>>s>>e>>t;
			addedge(s,e,-t);
		}
		if (!spfa(n)) cout<<"YES\n";
		else cout<<"NO\n";
	}
	return 0;
}

多源最短路问题

求解所有两点间最短路的问题。

Floyd-Warshall算法

时间复杂度O(V^3)

const int maxn=300;
int d[maxn][maxn]; //i,j无边时，d[i][j]=INF  i=j时，d[i][j]=0 
int n;

void warshall_floyd(){
	for (int k=0; k<n; k++){
		for (int i=0; i<n; i++){
			for (int j=0; j<n; j++)
				d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
		}
	}
}
HDU1874
#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
int n,m;
const int maxn=300;
int d[maxn][maxn]; //i,j无边时，d[i][j]=INF  i=j时，d[i][j]=0 

void warshall_floyd(){
	for (int k=0; k<n; k++){
		for (int i=0; i<n; i++){
			for (int j=0; j<n; j++)
				d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
		}
	}
}

int main() {

	ios::sync_with_stdio(0);
	cin.tie(0);
	while (cin>>n>>m){
		for (int i=0; i<n; i++){
			for (int j=0; j<n; j++){
				if (i==j) d[i][j]=0;
				else d[i][j]=INF;
			}
		}
		while (m--){
			int a,b,x;
			cin>>a>>b>>x;
			if (d[a][b]>x) //判断重边
				d[a][b]=d[b][a]=x;
		}
		warshall_floyd();
		int s,t;
		cin>>s>>t;
		if (d[s][t]==INF) cout<<-1<<endl;
		else cout<<d[s][t]<<endl;
	}
	return 0;
}

//也可用dijkstra写，但是每次输入要清空G

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
typedef pair<int, int> P; //first：最短距离 second：顶点编号
struct edge {
	int to,cost;
};

const int maxn=1010;
int n,m;
vector <edge> G[maxn];
int d[maxn];

void dijkstra(int s) {
	//堆按照first从小到大顺序取出值
	priority_queue<P, vector<P>, greater<P> > que;
	fill(d,d+n,INF);
	d[s]=0;
	que.push(P(0, s));
	while (!que.empty()) {
		P p=que.top();
		que.pop();
		int v=p.second;
		if (d[v]<p.first) continue;
		for (int i=0; i<G[v].size(); i++) {
			edge e=G[v][i];
			if (d[e.to]>d[v]+e.cost) {
				d[e.to]=d[v]+e.cost;
				que.push(P(d[e.to], e.to));
			}
		}
	}
}

void addedge(int u,int v, int w){
	edge t;
	t.to=v;
	t.cost=w;
	G[u].push_back(t);
}


int main() {

    ios::sync_with_stdio(0);
    cin.tie(0);
    while (cin>>n>>m){
        for (int i=0; i<n; i++) G[i].clear();
		while (m--){
            int a,b,x;
            cin>>a>>b>>x;
            addedge(a,b,x);
            addedge(b,a,x);
        }
        int s,t;
        cin>>s>>t;
        dijkstra(s);
        if (d[t]==INF) cout<<-1<<endl;
        else cout<<d[t]<<endl;
    }
    return 0;
}
爱吃猫的鱼
关注
专栏目录
java 二维数组 floyd_弗洛伊德（Floyd）算法求任意两点间的最短距离（JAVA）
weixin_32448581的博客
02-13 1204
(3)依次向S中加入v0 ,v1… vn-1，每加入一个顶点，对dist[i][j]进行一次修正：设S={v0 ,v1…vk-1}，加入vk，则dist(k)[i][j] = min{dist(k-1)[i][j]，dist(k-1)[i][k]+dist(k-1)[k][j]}。dist(k)[i][j]的含义：允许中间顶点的序号最大为k时从vi到vj的最短路径长度。dist(n-1)[i][...
最短路径算法复杂度总结
basycai的博客
02-29 2万+
Dijkstra：O(n2)适用于权值为非负的图的单源最短路径，用斐波那契堆的复杂度O(E+VlgV)， BellmanFord：适用于权值有负值的图的单源最短路径，并且能够检测负圈，复杂度O(VE) SPFA：适用于权值有负值，且没有负圈的图的单源最短路径，论文中的复杂度O(kE)，k为每个节点进入Queue的次数，且k一般但此处的复杂度证明是有问题的，其实SPFA的最坏情况应该是O(VE)
矩阵方格中求两点之间的最短路径java版
04-26
7*5矩阵方格中，红色A绕过障碍物到达B，移动规则： 1.A向周围8个小方格移动但是不能移动到旁边有球的方格 2.A球需要用最短路径到达B 求：用java实现该算法
二维数组最短路径
快乐星球
03-23 5946
题目描述： 给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 说明：每次只能向下或者向右移动一步。 示例: 输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 7 解释: 因为路径 1→3→1→1→1 的总和最小。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/...
递归之求二维数组的最短路径、给定一个整数和一个数组任意选择数组中的数累加能否得到该整数...
weixin_33897722的博客
06-07 378
1.给你一个二维数组，二维数组中的每个数都是正数，要求从左上角走到右下角，每一步只能向右或向下沿途经过的数字要累加起来，返回最小路径和 1 # i,j确定则返回值固定 2 def walk(matrix, i, j): 3 if i == len(matrix)-1 and j == len(matrix[0])-1: # 到达右下角，返回节点值 4 ...
动态最短路_动态最短路算法程序_
10-03
动态最短路算法是图论中的一个重要概念，用于在带权重的有向或无向图中寻找从一个起点到其他所有节点的最短路径。在实际应用中，它广泛应用于网络设计、物流优化、交通路线规划等领域。在这个场景中，我们讨论的是...
第六讲+最短路与设备更新.pdf
09-19
最短路问题是图论中的一个重要问题，其核心是寻找从图中一个顶点到另一个顶点的权值总和最小的路径。这类问题在现实世界中有着广泛的应用，包括但不限于电路布线、交通规划、运输网络分析以及求解最小费用流等。最...
算法_matlab_模拟退火_最短路_
09-29
通过模拟退火算法求解最短路径问题，可以避免陷入局部最优，尤其在图中存在多条几乎等价的最优路径时，能提高找到全局最优解的可能性。不过，算法的性能依赖于参数的选择，如初始温度、冷却因子和迭代次数，这些都...
模拟退火算法求最短路.zip
08-21
本文将深入探讨模拟退火算法的基本原理、其在求最短路问题中的应用以及MATLAB实现的细节。 模拟退火算法的核心思想是允许在搜索过程中接受一些较劣的解，以避免过早陷入局部最优解，从而有更大的概率找到全局最优解...
蚁群算法求解最短路，详细，可用于路径规划
02-20
在最短路问题中，目标是找到在给定网络中两个节点之间的最短路径。这种问题广泛存在于物流、交通、网络设计等领域。蚁群算法通过迭代过程，每只“虚拟蚂蚁”在图上随机行走，并根据信息素浓度和距离因子选择下一步的...
Java实现"最短路径FLOYD算法”
renhuihhh的专栏------致力于自学java的钻研
11-21 1585
<br />/**<br /> * title_最短路径问题 made by 任辉 2010-10-22<br /> */<br /> <br />publicclass Task7_15 {<br />    privateint[][] l = { { 0, 0, 0, 0, 0 }, { 0, 0, 7, 1, 6 },<br />                          { 0, 100, 0, 9, 100 }, <br />                          { 0,
最短路算法总结
luogu_bling的博客
10-09 775
最短路算法总结
最短路-四种算法复杂度分析比较 HDU-1874 畅通工程
蓦然回首
08-21 2060
样例解析： 每组数据第一行包含两个正整数N和M(0#include <stdio.h> #include <string.h> #include <algorithm> using namespace std; const int inf = 1<<30; int n,m; int map[300][300]; int vis[300],cast[300]; void Dijkstra(int s
Dijkstra算法求由顶点a到顶点h的最短路径
weixin_47230213的博客
05-25 1954
问题 下图使用Dijkstra算法求由顶点a到顶点h的最短路径，按实验报告模板编写算法。 解析 Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。 然后，从dis数组选择最小值，
2、最短路径算法
qq_45312141的博客
06-20 603
最短路径算法1、Dijkstra算法2、Floyd算法3、Bellman-Ford算法 1、Dijkstra算法 思想：广度优先算法、贪心算法 时间复杂度：是O(n2)O(n^2)O(n2) 算法思想 算法图解 2、Floyd算法 动态规划的思想 时间复杂度为：O(n3)O(n^3)O(n3) 算法的特点： 弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理有向图或有向图或负权（但不可存在负权回路)的最短路径问题，同时也被用于计算有向图的传递闭包。 算法的思路 通过FloydFl
最短路方法总结（参考acwing，自用）
最新发布
m0_73984272的博客
10-07 61
时间复杂度：O(n^2)应用场景：稠密图特点：使用邻接矩阵存图注意：无向图需记录两次·设dis[1]=0,其他dis[i]=INF；·循环n次{在所有未标号的节点中选出dis[x]最小的节点x对节点x标记对于x出发的所有边（x，y），更新d[y]=min( , )·}·已经标记过的点再也不会遍历代码略。
各种最短路算法能够处理的情况（优劣比较，时间复杂度等）
ShineEternal的笔记小屋
10-16 894
Floyd：只有时间复杂度是三次方较高 dijkstra：不能处理有负边权。 spfa：不能处理有负权回路。
最短路的三种算法（Floyd、Dijkstra、SPFA）
热门推荐
小女不才
12-14 2万+
前言乍一看搜索跟这个一样都可以找出一个点到另一个点的最短距离，但是有些问题两者都可以解决，而另一些搜索就不能解决了，搜索有确定的方向一步一步走，而最短路是告诉你某两个点直接可以直接走，没有确定的方向。最短路问题，通俗的说就是就是给你n个点，m条边，然后找出某两个点之间的最短距离。解决最短路常用的有三种算法Floyd、Dijkstra、SPFA。三种方法各有优劣 Floyd算法是多源最短路算法，复杂度
最短路算法详解与应用
"最短路算法的PPT讲义，主要涵盖了如何详细描述和总结最短路算法。" 最短路算法是图论中的一个重要概念，用于寻找图中两个节点之间的最短路径。常见的最短路算法有Dijkstra算法、Floyd-Warshall算法和Bellman-Ford...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值