Dijkstra求最短路

Dijkstra求最短路

dijkstra算法是利用贪心的策略，每次遍历访问一结点未被访问的邻接结点，每次比较距离决定是否更新最短路。

一、朴素dijkstra算法

在数据范围较小的时候，可以使用邻接矩阵的储存方式完成dijkstra算法。

• 首先声明一个二维数组g用于储存两节点的距离，在初始化时将其设置为0x3f3f3f3f（即两节点未连接之前距离为无限大），由于存在重边，每次比较取最小值即可。即g [i] [j]存储的就是i到j的距离。

• 然后利用取当前距离起始点最近的点，因为该点的距离已经被确定为最小。以该点为始点，遍历与之邻接的结点，更新距离。重复该过程。

• 最后输出即可。

代码：

int g[N][N],d[N];
bool vis[N];

int dijkstra()
{
    memset(d,0x3f,sizeof d);//将d初始化
    d[1] = 0;
    
    for(int i = 0;i < n;i++)
    {
        int t = -1;
        for(int j = 1;j <= n;j++)
            if(!vis[j] && (t == -1 || d[t] > d[j]))//如果j未曾作为最小值且t=-1或者t到起始点的距离比j大，则将t更新为j
                t = j;
        
        vis[t] = 1;//将t点标记
        for(int j = 1;j <= n;j++)
            d[j] = min(d[j],d[t] + g[t][j]);
    }
    
    if(d[n] == 0x3f3f3f3f)return -1;
    return d[n];
}

如题：849. Dijkstra求最短路 I - AcWing题库

代码如下：

#include<iostream>
#include<cstring>
using namespace std;
const int N = 503;

int n,m;
int g[N][N],d[N];
bool vis[N];

int dijkstra()
{
    memset(d,0x3f,sizeof d);//将d初始化
    d[1] = 0;
    
    for(int i = 0;i < n;i++)
    {
        int t = -1;
        for(int j = 1;j <= n;j++)
            if(!vis[j] && (t == -1 || d[t] > d[j]))//如果j未曾作为最小值且t=-1或者t到起始点的距离比j大，则将t更新为j
                t = j;
        
        vis[t] = 1;//将t点标记
        for(int j = 1;j <= n;j++)
            d[j] = min(d[j],d[t] + g[t][j]);
    }
    
    if(d[n] == 0x3f3f3f3f)return -1;
    return d[n];
}

int main()
{
    memset(g,0x3f,sizeof g);
    cin >> n >> m;
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        g[a][b] = min(g[a][b],c);
    }
    
    printf("%d\n",dijkstra());
    
    return 0;
}

二、用小根堆优化后

在朴素算法中，使用的是邻接矩阵储存和for循环求最小值，在处理数据较小的案例时该方法尚可，但是将数据范围调整至1e5时，这种方式就会因为超出数组的范围和排序太慢等原因而不适用。这时候，利用邻接表和小根堆就可以极大程度地优化。这里采用优先队列，当然也可以手写堆排序。堆排序的写法：C++模拟堆_Kicamon的博客-CSDN博客

如题：850. Dijkstra求最短路 II - AcWing题库

首先是邻接表的构建：

void add(int a,int b,int c)
{
    e[idx] = b,ne[idx] = h[a],d[idx] = c,h[a] = idx++; 
}

然后是dijkstra函数了：

int dijkstra()
{
    memset(dixt,0x3f,sizeof dixt);
    dixt[1] = 0;
    
    priority_queue<PII,vector<PII>,greater<PII>>q;
    q.push({0,1});
    
    
    while(q.size())
    {
        PII t = q.top();
        q.pop();
        
        if(vis[t.second])continue;
        int p = t.second;
        vis[p] = 1;
        for(int i = h[p];i != -1;i = ne[i])
        {
            int j = e[i];
            if(dixt[j] > dixt[p] + d[i])
            {
                dixt[j] = dixt[p] + d[i];
                q.push({dixt[j],j});
            }
        }
    }
    
    if(dixt[n] == 0x3f3f3f3f)return -1;
    return dixt[n];
}