单源最短路径dijkstra算法的初步学习（1）

最新推荐文章于 2021-01-24 20:19:49 发布

acm_lkl

最新推荐文章于 2021-01-24 20:19:49 发布

阅读量557

点赞数 2

分类专栏：学习心得文章标签：数据结构单源最短路

本文链接：https://blog.csdn.net/acm_lkl/article/details/38239567

版权

学习心得专栏收录该内容

15 篇文章 0 订阅

订阅专栏

今天学长给我们讲了求最短路的4种算法以及它们具体的应用。然后今晚写了好久才把第一个dijkstra算法写好。。。。。。。。

对于dijkstra算法共有3个版本：基础版及用优先队列,堆进行优化的版本。

对于基本版的算法，其实我觉得它和求最小生成树的prime()算法很是类似,无论是从思想还是代码的实现上。

我把它的代码分为2个部分,第一部分是初始化:包括dist数组，visited数组。第二部分是在n次循环的过程中

利用贪心的实现每次找到一个dist值最小的顶点,然后标记,然后再对和这个顶点相连的其它顶点的dist值进行

修改。这个思路的时间复杂度为n^2。

具体代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

#define Max 100
#define INF 1<<30   //不要用0x7fffffff表示最大值 

//fa[]数组存储每个顶点的父节点好用于打印路径 
int fa[Max],visited[Max],dist[Max]; //dist数组用来保存每个点到源点的最短路径长度 
int map[Max][Max];
int n,m;  //n个顶点m条边的有向图 

void dijkstra(int s)  //s开始的单源最短路 
{
     int i,j,k;
     for(i=0;i<n;i++)  //初始化fa[]数组(此处不是必要的) 
         fa[i]=i; 
     memset(visited,0,sizeof(visited));  //初始化访问标记数组
     for(i=0;i<n;i++)
     { 
        dist[i]=map[s][i];    //初始化dist[]数组
        if(map[s][i]<INF)   //将与s相邻的顶点的父节点改为s 
           fa[i]=s; 
     } 
     visited[s]=1;  //标记源点已访问
     for(i=0;i<n;i++)   //进行n次循环
     {
         int min=INF,mini;
         for(j=0;j<n;j++)  //寻找与源点距离最短的点 
         {
             if(!visited[j]&&dist[j]<min)
             {
                  min=dist[j];
                  mini=j;                   
             }
         } 
         visited[mini]=1;  //标记
         for(j=0;j<n;j++)   //对mini的相邻点的dist值进行更新 
            if(!visited[j]&&dist[mini]+map[mini][j]<dist[j])
            {
                  dist[j]=dist[mini]+map[mini][j];
                  fa[j]=mini;   //更新父节点信息 
            }     
     } 
} 

bool used[Max];
void Init()  //图邻接矩阵的初始化 
{
    int i,j;
    for(i=0;i<n;i++)
    {
       for(j=0;j<n;j++)
           map[i][j]=INF;  //图中所有边的权值初始都为无穷大
        map[i][i]=0;    //保证源点到自身的最短路为0 
    } 
} 

int main()
{
    int i,j,k1,k2,w;
    while(cin>>n>>m)
    {
         Init(); 
         for(i=0;i<m;i++)
         {
             cin>>k1>>k2>>w;
             map[k1][k2]=w;
         }
         dijkstra(0);
         for(i=0;i<n;i++)
            cout<<dist[i]<<" ";
         cout<<endl;
    }
}

第二种思路是用邻接表和优先队列对上面的代码实行优化。具体的优化有两个地方:第一个是利用优先队列的性质

优化寻找具有最小dist值顶点i的过程；这个需要自定义一个小整数优先的优先队列,定义好后，每次寻找只需要一个p.top()就行。第二个是用邻接表优化对i的邻结点的访问；用邻接矩阵表示图的时候对每一个顶点都要试探一下是不是

i的邻结点,而用邻接表表示后就能保证只访问i的邻结点而不会有多余的试探了。经过这两个优化后，算法的时间复杂度就降为mlongn了(m是边数)。所以这种算法适用于边比较少的稀疏图，不过刘汝佳讲无论边多不多，反正下面这个

都要比上面那个快。。。。。。。。

代码如下：

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>//使用pair的头文件
using namespace std;

#define INF 1<<30
#define Max 1000

int n,m;
int fa[Max],visited[Max],dist[Max];
int first[Max],u[Max],v[Max];
int w[Max],next[Max];

typedef pair<int,int> pii;   //定义此类型配合优先队列的使用
priority_queue<pii,vector<pii>,greater<pii> >q;  //定义了一个pill型,小整数优先的优先队列

void dijkstra(int s)
{
     int i,j,k;
     for(i=0;i<n;i++)  //dist初始化
        dist[i]=i==s?0:INF;//与前面不同,此次只将源点自己到自己的dist值初始化为0,而不管他的邻结点   
     memset(visited,0,sizeof(visited));  //初始化访问标记数组
     q.push(make_pair(dist[s],s));  // 用源点初始化优先队列
     while(!q.empty())
     {
         pii u=q.top();q.pop();//取出dist值最小的点
         int x=u.second;  //取出dist值最小点的顶点编号
         if(visited[x])    //如果已经访问过了抛弃这个点 
            continue; 
         visited[x]=1;
         for(int e=first[x];e!=-1;e=next[e])   //邻接表主要用来优化寻找从x出发的边这一步 
             if(dist[v[e]]>dist[x]+w[e])  // 第e条边(即以x为起点,v[e]为终点的边的权值可直接由w[e]得) 
             {
                 dist[v[e]]=dist[x]+w[e];  //更新dist 
                 fa[v[e]]=x;  //更新父节点信息
                 q.push(make_pair(dist[v[e]],v[e]));  //将更新过的顶点入队 
             } 
     } 
} 

int main()
{
    int i,j,k;
    while(cin>>n>>m)
    {
         for(i=0;i<n;i++)
             first[i]=-1;  //初始表头first数组
         for(int e=0;e<m;e++)
         {
             cin>>u[e]>>v[e]>>w[e];//输入第e条边的起点 终点 权值
             next[e]=first[u[e]];  //头插法 
             first[u[e]]=e; 
         } 
         dijkstra(0);
         for(i=0;i<n;i++)
             cout<<dist[i]<<" ";
         cout<<endl; 
    }
}

对于第3种利用堆进行优化的代码和上面第2种很像,主要好像是省了一个visited[]标记数组；但是虽然代码我写

出来了,但原理还是不太懂,明天还得请教一下

代码如下：

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>//使用pair的头文件
using namespace std;

#define INF 1<<30
#define Max 1000

int n,m;
int fa[Max],visited[Max],dist[Max];
int first[Max],u[Max],v[Max];
int w[Max],next[Max];

typedef pair<int,int> pii;   
priority_queue<pii,vector<pii>,greater<pii> >q;  

void dijkstra(int s)
{
     int i,j,k;
     for(i=0;i<n;i++)  
        dist[i]=i==s?0:INF;
     q.push(make_pair(dist[s],s));  
     while(!q.empty())
     {
		 while(!q.empty()&&q.top().first>dist[q.top().second]) q.pop();  //这一句是堆优化的关键之处,应该是可以避免重复访问,但现在我还不是太了解原理
		 if(q.empty()) break;
         pii u=q.top();q.pop();//取出dist值最小的点
         int x=u.second;  //取出dist值最小点的顶点编号
         for(int e=first[x];e!=-1;e=next[e])   //邻接表主要用来优化寻找从x出发的边这一步 
             if(dist[v[e]]>dist[x]+w[e])  // 第e条边(即以x为起点,v[e]为终点的边的权值可直接由w[e]得) 
             {
                 dist[v[e]]=dist[x]+w[e];  //更新dist 
                 fa[v[e]]=x;  //更新父节点信息
                 q.push(make_pair(dist[v[e]],v[e]));  //将更新过的顶点入队 
             } 
     } 
} 

int main()
{
    int i,j,k;
    while(cin>>n>>m)
    {
         for(i=0;i<n;i++)
             first[i]=-1;  //初始表头first数组
         for(int e=0;e<m;e++)
         {
             cin>>u[e]>>v[e]>>w[e];//输入第e条边的起点 终点 权值
             next[e]=first[u[e]];  //头插法 
             first[u[e]]=e; 
         } 
         dijkstra(0);
         for(i=0;i<n;i++)
             cout<<dist[i]<<" ";
         cout<<endl; 
    }
}