迪杰斯特拉算法

Posted 2023-04-16 929code

一. 概述

Dijkstra算法是求一个顶点到其余各顶点的最短路径算法-
迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略
每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止

二. 算法流程

1. 建立图的存储结构（邻接矩阵/邻接表）
2. 初始化图
3. 初始化源点到各点路径长度
4. 初始化当前访问顶点集合并将源点加入
5. 贪心寻找下一个未入集合的最近节点
6. 将该节点加入已经访问顶点集合
7. 以该节点为媒介更新其他顶点距离（未访问）
8. 重复567操作n-1次
9. 返回结果

三. 实例

vector<vector<int>> graph;//邻接矩阵
    Graph(int n, vector<vector<int>>& edges) //初始化图
        graph.resize(n);
        for(auto &point:graph)
            point.resize(n,INT_MAX);//初始赋无穷远距离
        for(int i=0;i<edges.size();i++)
            int from = edges[i][0];
            int to = edges[i][1];
            int cost = edges[i][2];
            graph[from][to] = cost;
             
    

    void addEdge(vector<int> edge) //加入边
            int from = edge[0];
            int to = edge[1];
            int cost = edge[2];
            graph[from][to] = cost;
    

获取起点到终点的最短路径长度

    int shortestPath(int node1, int node2) 
        if(node1==node2) return 0;
        int n =graph.size();
        vector<int> dis(n);//记录到各点的距离
        vector<bool> mark(n);//标记访问情况
        mark[node1] = true;//加入源点
        for(int i=0;i<n;i++)
            dis[i] = graph[node1][i];//初始化源点到各点距离
        
        for(int count=1;count<n;count++)//更新n-1次
            int minpath = INT_MAX;//记录最小距离
            int nextpoint = -1;//下一个邻近节点
            for(int i=0;i<n;i++)//贪心找下一个最近节点
            
                if(mark[i]==0&&dis[i]<minpath)
                    minpath = dis[i];
                    nextpoint = i;
                
            
            if(nextpoint==node2) return dis[node2];
            //如果没有下一个邻近节点
            if(nextpoint==-1) return -1;
            
            mark[nextpoint] = true;//将节点加入访问集合
            for(int i=0;i<n;i++)//根据新加入的节点更新所有节点离源点的距离
                if(graph[nextpoint][i]<INT_MAX&&mark[i]==false)//该点到新加入节点有边
                    if(dis[i]>dis[nextpoint]+graph[nextpoint][i])
                        dis[i]=dis[nextpoint]+graph[nextpoint][i];//更新该点到源点距离
                    
                
    
        
        return dis[node2]==INT_MAX?-1:dis[node2];
    

算法-迪杰斯特拉算法（dijkstra）-最短路径

迪杰斯特拉算法（dijkstra）-最短路径

 

简介：

迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

算法思想：

设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将加入到集合S中，直到全部顶点都加入到S中，算法结束），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点到S中各顶点的最短路径长度不大于从源点到U中任何顶点的最短路径长度。

算法步骤：

G={V,E}

1. 初始时令 S={V0},T=V-S={其余顶点}，T中顶点对应的距离值

若存在<V0,Vi>，d(V0,Vi)为<V0,Vi>弧上的权值

若不存在<V0,Vi>，d(V0,Vi)为∞

2. 在（T）未确定的点中选取当前以得的最短路径（与S中顶点有关联边且权值最小）

3. 对其余T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的距离值缩短，则修改此距离值

重复上述步骤2、3，直到S中包含所有顶点，即W=Vi为止

算法实例：

代码实例：

 1 #include<iostream>
 2 #include<cstring>
 3 #define INF  1000000 
 4 using namespace std;
 5 const int maxn=1000;
 6 int dis[maxn],g[maxn][maxn],n;//存储最短距离，图矩阵，顶点数 
 7 bool v[maxn];   //判断顶点是否访问 
 8  
 9 void dijkstra()
10 {
11     for(int i=1;i<=n;++i) 
12     dis[i]=INF;//初始化最短距离 
13     dis[1]=0;//到自身的距离为0 
14     memset(v,0,sizeof v); //初始化为未访问 
15    for(int i=1;i<=n;++i)
16     {
17         int mark=-1,mindis=INF;
18         for(int j=1;j<=n;++j)
19         if(!v[j]&&dis[j]<mindis)//在未确定的点中取当前以得最短路径 
20         {
21             mindis=dis[j];
22             mark=j;
23         }
24         v[mark]=1;
25         for(int j=1;j<=n;++j)//更新最短路径 
26         if(!v[j])
27         dis[j]=min(dis[j],dis[mark]+g[mark][j]);
28     }
29 }
30 int main()
31 {
32     int m,a,b,c;//边数，顶点a,b,权重 
33 memset(g,10000,sizeof g);// 初始化图矩阵 
34
35     cin>>n>>m;
36     for(int i=0;i<m;i++)
37     {
38         cin>>a>>b>>c;
39         g[a][b]=c;
40         g[b][a]=c;
41     }
42     dijkstra();
43         for(int i=1;i<=n;i++)
44     {
45         cout<<dis[i]<<endl;
46     }
47     return 0;
48  } 

 

ps:无负边

ps:部分资料来源网上