最短路问题的各种求法（二）Dijkstra算法

最短路问题的各种求法（二）Dijkstra算法

问题描述

给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出 −1。

朴素版Dijkstra算法

1. 把所有点到源点的距离初始化为0x3f3f3f3f3(正无穷),把源点到源点的距离初始化为0;

 		memset(dis,0x3f,sizeof dis);
    	dis[1]=0;

2. 在所有没有被优化完的点(根据(st数组判断)里面找到到源点路径最小的点,并用这个点到源点的距离来更新所有点到源点的距离

 		for(int j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dis[t]>dis[j]))t=j;
        }
        for(int j=1;j<=n;j++)
            dis[j]=min(dis[j],dis[t]+d[t][j]);

3. 将该点加入st数组表示已经被优化完

  	st[t]=true;

4. 重复2-3步直到所有点都加入st中

朴素版Dijkstra算法完整代码

	#include<iostream>
	#include<algorithm>
	#include<cstring>
	using namespace std;
	const int N=1e5+10,M=510;
	int d[M][M];
	bool st[M];
	int dis[M];
	int n,m;
	int Dijkstra()
	{
	    memset(dis,0x3f,sizeof dis);
	    dis[1]=0;
	    for(int i=1;i<=n;i++)
	    {
	        int t=-1;
	        for(int j=1;j<=n;j++)
	        {
	            if(!st[j]&&(t==-1||dis[t]>dis[j]))t=j;
	        }
	        st[t]=true;
	        for(int j=1;j<=n;j++)
	            dis[j]=min(dis[j],dis[t]+d[t][j]);
	    }
	    if(dis[n]>0x3f3f3f3f/2)return -1;
	    return dis[n];
	}
	int main()
	{
	    cin>>n>>m;
	    for(int i=1;i<=n;i++)
	    {
	        for(int j=1;j<=n;j++)
	        {
	            if(i==j)d[i][j]=0;
	            else d[i][j]=0x3f3f3f3f;
	        }
	    }
	    while(m--)
	    {
	        int a,b,c;
	        cin>>a>>b>>c;
	        d[a][b]=min(d[a][b],c);
	    }
	    cout<<Dijkstra()<<endl;
	}

堆优化版的Dijkstra算法

朴素版Dijkstra算法适用于稠密图所以用邻接矩阵来存储，当m与n在一个数量级也就是稀疏图的时候我们可以用邻接表来存储
因为每次都需要选择路径最小的边来更新之后的每一条边所以这里可以用小根堆来存储
定义小根堆

	priority_queue<PII, vector<PII>, greater<PII>> heap;

在小根堆里面存取的是一个pair<路径长度,点>因为pair是根据第一个元素进行排序的所以我们把路径的长度放在pair的第一个位置

1. 将源点放入堆中并更新源点到源点的距离

 		heap.push({0,1});//距离，点
  		dis[1]=0;

2.当堆不空的时候每次取出距离源点最近的点，并对没有被优化的每个点进行优化,如果有某个点的边被优化了说明与这个点相连的点也可以进行优化，那样我们就可以把这个点标记为已经被优化过并且将<这个点到源点的距离，这个点>入堆

		while(!heap.empty())
	    {
	        PII t=heap.top();
	        heap.pop();
	        int dian=t.y;
	        if(!st[dian])
		    {
		        st[dian]=true;
		        for(int i=h[dian];i!=-1;i=ne[i])
		        {
		            int j=e[i];
		            if(dis[j]>dis[dian]+w[i])
		            {
		                dis[j]=dis[dian]+w[i];
	                   heap.push({dis[j],j});	                }
		            }
		         }
	    	 }
	      }

堆优化版Dijkstra算法完整代码

	#include<iostream>
	#include<cstring>
	#include<queue>
	#include<algorithm>
	using namespace std;
	typedef pair<int,int> PII;
	#define x first
	#define y second
	const int N=150010;
	int h[N],e[N],ne[N],w[N],idx;
	bool st[N];
	int dis[N];
	int m,n;
	void add(int a,int b,int c)
	{
	    e[idx]=b;
	    ne[idx]=h[a];
	    w[idx]=c;
	    h[a]=idx++;
	}
	int Dijkstra()
	{
	    priority_queue<PII, vector<PII>, greater<PII>> heap;
	    heap.push({0,1});//距离，点
	    dis[1]=0;
	    while(!heap.empty())
	    {
	        PII t=heap.top();
	        heap.pop();
	        int dian=t.y;
	        if(!st[dian])
	        {
	            st[dian]=true;
	            for(int i=h[dian];i!=-1;i=ne[i])
	            {
	                int j=e[i];
	                if(dis[j]>dis[dian]+w[i])
	                {
	                    dis[j]=dis[dian]+w[i];
	                    heap.push({dis[j],j});
	                }
	            }
	        }
	    }
	    if(dis[n]>0x3f3f3f3f/2)return -1;
	    return dis[n];
	}
	int main()
	{
	    scanf("%d %d",&n,&m);
	    memset(h,-1,sizeof h);
	    memset(dis,0x3f,sizeof dis);
	    while(m--)
	    {
	        int a,b,c;
	        scanf("%d %d %d",&a,&b,&c);
	        add(a,b,c);
	    }
	    cout<<Dijkstra();
	    return 0;
	}