图的最短路径算法

最新推荐文章于 2022-11-22 21:53:23 发布
最新推荐文章于 2022-11-22 21:53:23 发布
阅读量479 收藏
点赞数 1
分类专栏： 算法 文章标签： 图论 dijkstra dfs 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41600708/article/details/115866865
版权

图的最短路径算法

dfs

使用dfs遍历计算最短路径

void dfs(int cur,int dst){
    //当前的路劲大于之前的最短路劲就不用走了
    if(minpath < dst) return;
    //临界条件，当走到终点n
    if(cur == en){
        if(minpath > dst){
            minpath = dst;
            return;
        }
    }
    for(int i=1;i<=n;i++){
        //i节点未访问过，cur->i有边，则进入
        if(mark[i] == 0 && edge[cur][i] != inf && edge[cur][i] != 0){
            mark[i] = 1;
            dfs(i,dst+edge[cur][i]);
            mark[i] = 0;
        }
    }
    return ;
}

例子,输入n和m然后输入三个数，分别表示a->b的边和权重edge,然后根据dfs找到0到n的最短路径

#include <btis/stdc++.h>
using namespace std;
#define nmax 110
#define inf 999999999
//最短路劲，节点数，边数，终点，邻接矩阵,节点访问标记
int minpath,n,m,en,edge[nmax][nmax],mark[nmax];

void dfs(int cur,int dst){
    //当前走过的已经超过了minpath则直接返回
    if(minpath < dst) 
        return;
    //临界条件，当走到终点n
    if(cur == en){
        if(minpath > dst){
            minpath = dst;
            return ;
        }
    }
    for(int i=1;i<=n;i++){
        if(mark[i] == 0 && edge[cur][i]] != inf && edge[cur][i]){
            mark[i] = 1;
            dfs(i,dst+edge[cur][i]);
            mark[i] = 0; //dfs之后访问标志重置为0
        }
    }
    return;
}

int mian(){
    while(cin >> n >> m && n != 0){
        //初始化邻接矩阵
        for(int i=1;i <= n;i++){
            for(int j=1;j <= n;j++){
                edge[i][j] = inf;
            }
            edge[i][i] = 0;
        }
        //写入m条边
        int a,b;
        while(m--){
            cin >> a >> b;
            cin >> edge[a][b];
        }
        minpath = inf;
        memset(mark,0,sizeof(mark));
        mark[1] = 1; 
        //设定了结束的节点就是n
        en = n; 
        dfs(1,0);
        cout << minpath << endl;
    }

}

BFS

利用BFS也是可以获得最短路径的

  1. 以一个节点为起点，放入队列
  2. 取出队首节点node，然后在对应的位置，加入他的路径上一个节点path
  3. 把他的邻接节点放入队列
  4. 如果队列不为空，回到2

Folyed佛洛依德算法(解决多远最短路劲)

思想

最开始只允许经过1号顶点进行中转，接下来只允许进过1号和2号顶点进行中转。。。允许经过1~n号所有顶点进行中转，来不断动态更新任意两点之间的最短距离，即求从i好顶点到j顶点只经过前k号顶点的最短距离

算法分析
  • 首先构造邻接矩阵edge[n+1][n+1],假如只经过1号节点，求任意两点最短距离，显然edge[i][j] = min(edge[i][j],edge[i][1]+edge[1][j])
  • 接下来允许经过1号和2号顶点，在已经经过1号节点前提下插入2号节点啦更新，
  • 显然n次更新之后，最后求得的edge[i][j]就是从i号顶点到J号顶点只经过n号点的最短路径
核心代码
#include <iostream>
using namespace std;
#define nmax 110
#define inf 999999999
//最短路劲，节点数，边数，终点，邻接矩阵,节点访问标记
int minpath,n,m,en,edge[nmax][nmax],mark[nmax];

//取k=1时即所有节点经过1节点到后面所有节点的距离
//k为每次经过前k个节点到达的最短路径
// k是每次使用哪个节点作为中转
for(int k=1;k <= n;k++){
    for(int i=1;i <= n;i++){  //i为原来节点的
        // j 为目标节点的终点
        for(int j=1;j <= n;j++){
            //k可以到j，i可以到k,i到j的权大于i到k，再从k到j
            if(edge[k][j] < inf && edge[i][k] < inf && edge[i][j] > edge[i][k]+edge[k][j]){
                edge[i][j] = edge[i][k] + edge[k][j];
            }
        }
    }
}

例子

寻找最短的从商场到赛场的路线。其中商店在1号节点处，赛场在n号节点处，1~n节点中有m条线路双向连接。

/*先输入n，m，在输入m个三元组，n为路口数，m表示有几条路，其中1为商店，n为赛场，三元组分别表示起点终点，和该路径长，输出1到n的最短距离*/

#include<bits/stdc++.h>
using namespace std;
#define inf 999999999
#define nmax 110
int n,m,edge[nmax][nmax];
int main ()
{
    int a,b;
    while(cin>>n>>m&&n!=0){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                edge[i][j]=inf;
            }
            edge[i][i]=0;
        }
        while(m--){
           cin>>a>>b;
           cin>>edge[a][b];
           edge[b][a]=edge[a][b];
        }
        for(int k=1;k<=n;k++){
     for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(edge[k][j]<inf&&edge[i][k]<inf&&edge[i][j]>edge[i][k]+edge[k][j]){
               edge[i][j]=edge[i][k]+edge[k][j];
            }
        }
     }
     }
     cout<<edge[1][n]<<endl;
    }
}

2 1
1 2 3
3
3 3
1 2 5
2 3 5
3 1 2
2
0 0

迪杰斯特拉算法(解决单源最短路径)

  1. 把所有节点到达的路径设为 无穷大

  2. 最开始选择一个最短的路径点(起点,为0)

  3. 以最短的路径为起点更新能够到达的点的路径

  4. 在除去刚刚选择过的节点之外的节点中找到一个最小的节点X

    1. 刚刚取了起点，这次就在以起点为源更新了的节点里面找最短的路径节点

  5. 以X为起点更新能够到达的带你的路径

  6. 继续4，直到取完所有的节点了

算法
  1. 设置标志数组book[]标记哪些路径已经求得了最短路径了,已知的假如在P中，未知的加入在Q中
  2. 设置最短路劲数组dst[],刚开始时dst[i]=edge[s][i],(s为源点)即都是从源点到i的长度，此时dst[s]=0,book[s]=1,在book里面找一个里源点最近的顶点u加入P，已u为中转点对每一条边松弛(即s–>j途中经过u,dst[j]=min(dst[j],dst[u]+edge[u][j],并令book[u]=1))
  3. 再找一个离源点s最近的顶点v加入，已v中转对每一条松弛
  4. 重复3，知道集合Q为空
核心代码
#include<bits/stdc++.h>
using namespace std;
#define nmax 110
#define inf 999999999
/***构建所有点最短路径数组dst[],且1为源点***/
int u;/***离源点最近的点***/
int minx;
// 初始化(第一次以起点能到达的距离)
for(int i=1;i<=n;i++) dst[i]=edge[1][i];
// 初始化访问数组
for(int i=1;i<=n;i++) book[i]=0;
book[1]=1;
// 正式开始松弛
for(int i=1;i<=n-1;i++){
	// 先要从剩下的没有松弛的节点里面找到最小的节点
        minx=inf;
    for(int j=1;j<=n;j++){
        if(book[j]==0&&dst[j]<minx){
            minx=dst[j];
            u=j;
        }
    }
    book[u]=1;
    /***更新最短路径数组***/
    for(int k=1;k<=n;k++){
        if(book[k]==0&&dst[k]>dst[u]+edge[u][k]&&edge[u][k]<inf){
            dst[k]=dst[u]+edge[u][k];
        }
    }
}
例题

例1：给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s，终点t，要求输出起点到终点的最短距离及其花费，如果最短距离是有多条路线，则输出花费最少的。

输入：输入n，m，点的编号是1~n，然后是m行，每行4个数a，b，d，p，表示a和b之间有一条边，且长度为d，花费为p。最后一行是两个数s，t，起点s，终点t。n和m为0时输入结束。（1<n<=1000,0<m<100000,s!=t）

输出：输出一行，有两个数，最短距离及其花费。

分析：由于每条边有长度d和花费p，最好构建变结构体存放。

3 2
1 2 5 6
2 3 4 5
1 3

9 11
#include<bits/stdc++.h>
using namespace std;
#define nmax 110
#define inf 999999999
struct Edge{
    int len;
    int cost;
}edge[nmax][nmax];
int u,n,m,book[nmax],s,t,dst[nmax],spend[nmax];
int minx;
int main (){
    while(cin>>n>>m&&n!=0&&m!=0){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                edge[i][j].len=inf;
                edge[i][j].cost=0;
            }
            edge[i][i].len=0;
        }
        int a,b;
        while(m--){
            cin>>a>>b;
            cin>>edge[a][b].len>>edge[a][b].cost;
            edge[b][a].len=edge[a][b].len;
            edge[b][a].cost=edge[a][b].cost;
        }
        cin>>s>>t;
       for(int i=1;i<=n;i++) {dst[i]=edge[s][i].len;spend[i]=edge[s][i].cost;}
       for(int i=1;i<=n;i++) book[i]=0;
       book[s]=1;
    for(int i=1;i<=n-1;i++){
        minx=inf;
        for(int j=1;j<=n;j++){
        if(book[j]==0&&dst[j]<minx){
            minx=dst[j];
            u=j;
        }
    }
    book[u]=1;
    for(int k=1;k<=n;k++){
        if(book[k]==0&&(dst[k]>dst[u]+edge[u][k].len||(dst[k]==dst[u]+edge[u][k].len&&spend[k]>spend[u]+edge[u][k].cost))&&edge[u][k].len<inf){
            dst[k]=dst[u]+edge[u][k].len;
            spend[k]=spend[u]+edge[u][k].cost;
        }
    }
}
       cout<<dst[t]<<' '<<spend[t]<<endl;
    }
 }

Bellman-Ford算法

  • 可以用于含有负权值的图

算法过程

  1. 初始化所有点。每个点保存一个值，表示源点到达这个点的距离，将源点的值设为0，其他的点的值设为无穷大
  2. 激进型循环，循环下标为从1到n-1(n为图中点的个数)。在循环内部，遍历所有的边，进行松弛计算
  3. 遍历图中所有的边(edge(u,v)),判断是否存在这一的情况: d(v)>d(u)+edge(u,v),若存在，则返回false，表示图中存在从源点可达的权为负的回路（可能因为无法收敛导致不能求出最短路径）
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <stack>
using namespace std;
#define MAX 10000
struct Edge{
    int u;
    int v;
    int w;
};

Edge edge[10000];
int dist[100];
int path[100];
int vertex_num;
int edge_num;
int source;

bool BellmanFord(){
    // 初始化 
    for(int i=0;i<vertex_num;i++)
        dist[i] = (i == source) ? 0 : MAX;

    //n-1只是次数，并不需要使用节点的值，循环求最短路径 
    for(int i=1;i<=vertex_num;i++){
        for(int j=0;j<edge_num;j++){
            if(dist[edge[j].v] > dist[edge[j].u] + edge[j].w){
                dist[edge[j].v] = dist[edge[j].u] + edge[j].w;
                path[edge[j].v] = edge[j].u;
            }
        }
    }

    // 标记是否有负权回路 
    bool flag = true;

    //第N次判断负权 
    for(int i=0;i<edge_num;i++){
        if(dist[edge[i].v] > dist[edge[i].u] + edge[i].w){
            flag = false;
            break;
        }
    }

    return flag;
}

void Print(){
    for(int i=0;i<vertex_num;i++){
        if(i != source){
            int p = i;
            stack<int> s;
            cout << "顶点" << source << "到顶点" << p << " 的最短路径是:";
            // 路径逆向，要借助栈 
            while(source != p){
                s.push(p);
                p = path[p];
            }

            cout << source;
            // 一次从栈里取出来 
            while (!s.empty()){
                cout << "--" << s.top();
                s.pop();
            }
            cout << "    最短路径是:" << dist[i] << endl;
        }
    }
}

int main(){
    cout << "输入顶点数，边数，源点";
    cin >> vertex_num >> edge_num >> source;

    cout << "请输入" << edge_num << "条边的信息:\n";
    for(int i=0;i<edge_num;i++)
        cin >> edge[i].u >> edge[i].v >>edge[i].w;

    if(BellmanFord())
        Print();
    else
        cout << "Sorry, it have negative circle!\n";

    return 0;
}

SPFA算法

对Bellman-Ford算法的改进

还没看

例题

题目
平面上有n nn个点 ( N < = 100 ) (N <= 100 )(N<=100)，每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点直线的距离。现在的任务是找出从一点到另一点之间的最短路径。

输入
共有n + m + 3 n+m+3n+m+3行，其中：
第一行为一个整数n nn。
第2行到第n + 1 n+1n+1行（共n nn行），每行的两个整数x xx和y yy，描述一个点的坐标(以一个空格隔开)。
第n + 2 n+2n+2行为一个整数m mm，表示图中的连线个数。
此后的m mm行，每行描述一条连线，由两个整数I , j I,jI,j组成，表示第i ii个点和第j jj个点之间有连线。
最后一行：两个整数s ss和t tt，分别表示源点和目标点。

输出
一个实数(保留两位小数)，表示从 S SS 到 T TT 的最短路径的长度。

样例
input
5
0 0
2 0
2 2
0 2
3 1
5
1 2
1 3
1 4
2 5
3 5
1 5

output
3.41

Floyed算法

#include<iostream>
#include<iomanip>

#include<cstdio>
#include<cmath>
using namespace std;
int n,m,x,y;
double d[120][120];
struct c{
	double x,y;
}a[120];
int main()
{
	memset(d,0x7f,sizeof(d));
	scanf("%d",&n);
	for (int i=1;i<=n;i++)
	    cin>>a[i].x>>a[i].y;
	scanf("%d",&m);
	for (int i=1;i<=m;i++)
	{
		cin>>x>>y;
		d[y][x]=d[x][y]=sqrt(pow(a[x].x-a[y].x,2)+pow(a[x].y-a[y].y,2));
	}
	cin>>x>>y;
    // 开始Floyed算法
	for (int k=1;k<=n;k++)
	    for (int i=1;i<=n;i++)
	        for (int j=1;j<=n;j++)
	            if (i!=k&&j!=k&&i!=j&&d[i][j]>d[i][k]+d[k][j])
	               d[i][j]=d[i][k]+d[k][j];
	cout<<setprecision(2)<<fixed<<d[x][y]<<endl;
	return 0;
}

Dijkstra算法

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
const double maxn=0x7fffffff;
double d[10020][10020],dis[120];
int p[120],n,m,x2,y2,x[120],y[120];
int main()
{
	memset(dis,0x7f*1.0,sizeof(dis));
	scanf("%d",&n);
	for (int i=1;i<=n;i++)
	    cin>>x[i]>>y[i];
	scanf("%d",&m);
	for (int i=1;i<=m;i++)
	{
		cin>>x2>>y2;
		d[y2][x2]=d[x2][y2]=sqrt(pow(abs(x[x2]-x[y2]),2)+pow(abs(y[x2]-y[y2]),2)); 
	}   
	cin>>x2>>y2;
    // 设置初始的起点为0，因为单源最短路径算法，需要一个起点
	dis[x2]=0;
    // 开始Dijkstra算法
	for (int i=1;i<=n;i++)
	{
        // 先找到剩余的节点中的离源点最短路径的节点
        int k;
        double mi=maxn;
        k=0;
	    for (int j=1;j<=n;j++)
	        if (p[j]==0&&mi>dis[j])
	        {
	        	k=j;
	        	mi=dis[j];
	        }
        // 如果k是0，则说明没有更短的了，则全部松弛完了，结束
	    if(!k) break;
	    p[k]=1;
        // 松弛操作
	    for (int j=1;j<=n;j++)
	        if (p[j]==0&&d[j][k]!=0)
	           dis[j]=min(dis[j], dis[k]+d[j][k]);
	}
	printf("%.2lf",dis[y2]); 
	return 0;
}

Ford算法

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
int n,m,x2,y2;
int x[15000],y[15000],dx[15000],dy[15000];
double dis[15000],l[15000];
int main()
{
	memset(dis,0x7f*1.0,sizeof(dis));
	scanf("%d",&n);
	for (int i=1;i<=n;i++)
	    cin>>x[i]>>y[i];
	scanf("%d",&m);
	for (int i=1;i<=m;i++)
	{
		cin>>dx[i]>>dy[i];
		l[i]=sqrt((abs(x[dx[i]]-x[dy[i]]))*(abs(x[dx[i]]-x[dy[i]]))+(abs(y[dx[i]]-y[dy[i]]))*(abs(y[dx[i]]-y[dy[i]]))); 
	}   
	cin>>x2>>y2;
    // 也是单源的，需要一个起点的初始距离
	dis[x2]=0;
    // Bellman-Ford算法
	for (int i=1;i<n;i++)
	{
	    int p=0;
	    for (int j=1;j<=m;j++)
	    {
            // x->y 来更新 dis[y]
	    	if (dis[dx[j]]+l[j]<dis[dy[j]])
	    	{
	    		dis[dy[j]]=dis[dx[j]]+l[j];
	    		p=1;
	    	}
            // y -> x 更新 dis[x]
	    	if (dis[dy[j]]+l[j]<dis[dx[j]])
	    	{
	    		dis[dx[j]]=dis[dy[j]]+l[j];
	    		p=1;
	    	}
	    }
	    if (p==0) break;
	}
	printf("%.2lf",dis[y2]);
    return 0;
}
ikalpa
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【图】最短路径算法
半生瓜のblog
10-21 912
图的最短算法 从起点开始访问所有路径，可以到达终点的有多条地址,其中路径权值最小的为最短路径。 最短路径算法有深度优先遍历、广度优先遍历、Bellman-Ford算法、弗洛伊德算法、SPFA(Shortest Path Faster Algorithm)算法和迪杰斯特拉算法等。 ...
图的最短路径之(迪克斯特拉）Dijkstra算法代码实现
any_ways的博客
05-15 3075
一，Dijkstra算法 １，初始化：先找出从源Ｖ0到各终点Vk的直达路径（Ｖ0,Vk),即通过一条弧到达的路径．如果一条弧不能到达的点记为　无穷大 ２，选择：从这些路径中找出一条长度最短的路径（V0,U). 3，更新：然后从其余各条路径进行适当调整： 若在图中存在弧（U,Vk),且(V0,U) + (U,Vk) < (V0,Vk),则以路径(V0,U,Vk)代替(V0,Vk) 4，在调整后的各条路径中，再找长度最短的路径（依此类推）． 具体的操作为： １，把Ｖ（顶点）分成两组： ..
图--最短路径（四种算法详解）
m0_58642116的博客
02-26 1万+
图最短路径
图算法——求最短路径（Dijkstra算法）
热门推荐
在夜里行走的博客
11-22 8万+
图解Dijkstra算法，让你了解Dijkstra算法的每一步是怎么进行的
最短路径算法的编程与实现 C语言
timerring的博客
07-10 5万+
1.掌握最短路径算法的基本原理及编程实现；operating system version：Win11 CPU instruction set: x64 Integrated Development Environment：Viusal Studio 20221)建立一张图，选择一种存储结构(邻接矩阵或邻接表)初始化该图； 2)用Dijkstra算法实现点与点之间的最短路径。1) 实现图的两种表示方法； 2) 实现Dijkstra算法；1. 程序： 2.程序结果：1）程序运行，我使用的测试数据如下
最短路径dijkstra算法精品代码（超详解）
KING_阿飞的博客
08-13 3万+
一：简介 　　这个算法用于解决图中单源最短路径问题。所谓单源节点是指给定源节点，求图中其它节点到此源节点的最短路径。如下图所示：给定源节点a，求节点b到a的最短距离。 (图来自于参考资料2) 那么如何寻找？还是以上图为例： 1）初始化：设定除源节点以外的其它所有节点到源节点的距离为INFINITE(一个很大的数)，且这些节点都没被处理过。 ...
最短路径算法dijkstra的matlab实现_dijkstra_最短路径算法_
10-04
最短路径算法是图论中的一个经典问题，用于寻找图中两点之间最短的路径。Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出的一种解决这一问题的有效方法。本篇文章将深入探讨Dijkstra算法的基本原理、...
地图最短路径算法
03-24
标题提到的"地图最短路径算法"是这个话题的一个具体实例，通常涉及到如何在一个带有权重的图中找到两个节点之间的最短路径。在这个场景中，地图上的每个点可以看作是图的节点，而两点间的高度差则作为边的权重，代表...
Dijkstra最短路径算法的Matlab实现
08-23
Dijkstra最短路径算法是一种经典的图论算法，用于寻找图中节点间的最短路径。在计算机科学和网络路由中有着广泛的应用。Matlab作为一种强大的数值计算和可视化工具，非常适合用来实现这种算法。在这个项目中，我们有...
ArcGis Engine + C# + 最短路径算法
02-26
Dijkstra算法是一种保证找到两个点之间最短路径的单源最短路径算法，适用于没有负权边的图。而A*算法则是在Dijkstra基础上加入了启发式信息，提高了搜索效率，适用于有大量节点的情况。 实现最短路径算法通常包括...
c++求图的最短路径算法
12-28
c++求图的最短路径算法.c++求图的最短路径算法c++求图的最短路径算法
floyd最短路径算法MATLAB代码
08-29
求最短路径的Floyd算法实现，无向图和有向图均适用。1先区别有向图和无向图，2输入顶点数和边数并检查合法性，3输入每边的起点、终点、权重并检查合法性，并初始化邻接矩阵和路径矩阵，4调用自定义函数Floyd
数据结构与算法：图的最短路径问题（BFS,Dijkstra,Floyd）
weixin_50690285的博客
05-13 2677
数据结构与算法：图的最短路径问题（BFS,Dijkstra,Floyd）
C++数据结构之图的最短路径——Dijkstra&Floyd(包含算法实现以及gif图示)
m0_56398315的博客
09-04 4597
本文包含了对最短路径以及相关概念的解释，以及Dijkstra和Floyd算法求最短路径的C++算法实现，并包含了gif演示和相关图示
图的四种最短路径算法
lyp
12-23 1202
1.迪杰斯特拉算法 int u; int minx; for(int i=1;i<=n;i++) dst[i]=edge[1][i]; for(int i=1;i<=n;i++) book[i]=0;//初始化 book[1]=1; for(int i=1;i<=n-1;i++){ minx=inf; for(int j=1;j<=n;j++){ if(book[j]==0&&dst[j]<minx){
深入浅出：四种常用的最短路算法+两种常用生成树算法+网络流常用算法大礼包
csyifanZhang的博客
04-02 662
文章目录一、最短路径1：Dijkstra & 堆优化 & why not 负权边？2：Bellman-Ford：迭代与松弛2(2): 进阶版：Spfa & why 队列？3：Floyd：他死了二、最小生成树1：Prim 算法-给定初始点的最小生成树2：Kruskal算法-并查集based三、网络流四、图的匹配--二分图，一般图以及二分图的边覆盖、独立集和顶点覆盖 写了不少题...
图的最短路径（4种算法）
03-08 1987
#ifndef SHORTEST_PATH_H #define SHORTEST_PATH_H #include<queue> #include<limits.h> #include<memory> #include"../data_struct/data_struct.h" /// (1)当权值为非负时，用Dijkstra。 /// (2)当权值有负值...
高德地图最短路径算法
最新发布
11-29
高德地图路径规划2.0的算法是使用Dijkstra算法进行最短路径规划的。Dijkstra算法是一种贪心算法，它能够在有向图中求出单源最短路径。它的基本思想是，对于一个起点，求出到所有点的最短路径。具体实现过程如下： 1. 初始化：将起点到所有点的距离初始化为无穷大，将起点到自己的距离初始化为0。 2. 选择：从未确定最短路径的点中，选择距离起点最近的点。 3. 更新：更新与该点相邻的点的距离，如果经过该点到达相邻点的距离比原来的距离更短，则更新距离。 4. 标记：将该点标记为已确定最短路径。 5. 重复：重复2-4步，直到所有点都被标记为已确定最短路径或者没有与起点相连的点。 在高德地图中，Dijkstra算法被用于计算最短路径。用户输入起点和终点后，系统会根据地图数据计算出最短路径，并给出路线规划建议。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值