朴素Dijkstra与堆优化Dijkstra

朴素dijkstra：题目

当面对单源最短路问题时，若所有边均为正权，则可用Dijkstra算法求解。
思路：维护一个尚未确定到起点最短距离的点的集合，每次从该集合中选取一个到起点距离最短的点，则该点到起点的最短距离已近被确定，从该集合删除，并更新与该点相关的所有点距离(松弛操作)。
时间复杂度：O(n^2) ，n为点数。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 510;
int sides[N][N], dis[N];
bool cert[N]; // 判断点是否被确定

int dijkstra(int n)
{
    
    

    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(!cert[j] && (t == -1 || dis[t] > dis[j])) t = j; 

        cert[t] = true;
        
        for (int i = 1; i <= n ;i++) //更新与该点有关的点的距离
            dis[i] = min(dis[i], dis[t] + sides[t][i]);
            
    }
    int ans = dis[n] == 0x3f3f3f3f? -1 : dis[n];
    return ans;
}

int main()
{
    
    
    memset(sides, 0x3f, sizeof(sides));

    int n, m;
    cin >> n >> m;

    int x, y, z;
    while(m--)
    {
    
    
        cin >> x >> y >> z;
        sides[x][y] = min(z, sides[x][y]); //在重边中选择最短一条
    }

    cout << dijkstra(n) << endl;
    return 0;

}

堆优化版dijkstra：题目

在朴素算法中，可发现在寻找距离最短的点时对图中所有点均进行了扫描，为此，可以借助小根堆，通过堆排直接获得距离最短的点。
时间复杂度：O(mlogn) ，n为点数，m为边数。

#include <iostream>
#include <cstring>
#include <utility>
#include <queue>


using namespace std;
const int N = 150010;

typedef pair<int, int> PII;
int idx, e[N], ne[N], w[N], h[N], dis[N];
bool cert[N];

void add(int a, int b, int c) // 不同于朴素dijkstra，在此使用邻接表
{
    
    
    e[idx] = b, w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx++;
}

int dijkstra(int n)
{
    
    
    memset(dis, 0x3f, sizeof(dis));
    priority_queue<PII, vector<PII>, greater<PII> > heap;
    
    heap.push({
    
    0, 1});

    while(heap.size())
    {
    
    
        int num = heap.top().second;
        int distance = heap.top().first;
        heap.pop();
        
        if(cert[num]) continue;

        for (int i = h[num]; i != -1; i = ne[i])
        {
    
    
            int t = e[i];
            if (dis[t] > distance + w[i])
            {
    
    
                dis[t] = distance + w[i];
                if(!cert[t]) heap.push({
    
    dis[t], t});
            }
        }
        
        cert[num] = true;
    }

    int ans = dis[n] == 0x3f3f3f3f? -1 : dis[n];
    return ans;
}

int main()
{
    
    
    memset(h, -1, sizeof(h));
    
    int n, m;
    cin >> n >> m;
    
    int x, y, z;
    while(m--)
    {
    
    
        cin >> x >> y >> z;
        add(x, y, z);
    }

    cout << dijkstra(n) << endl;
    return 0;
}