dijkstra算法及其優化

dijkstra算法是經典的貪心算法。基本的想法是，有兩個集合S和E，開始S集合中只有一個起點，E集合中有剩下的其他點。遍歷E集合中的所有點，找出與起點距離最近的一個點，將其加入集合S，並用該點去更新起點到其他點的最短路徑。（注意該算法只能處理正邊權的圖）

 

 

由動圖結合上面的思路，我們可以看出，算法的基本框架是：

1.初始化
for i(0 -> n - 1)
{
    2.找出距離起點最近的點
    3.標記該點加入集合S
    4.用新加入集合S的點去更新起點到其他點的最短距離
}

1.其中初始化包括了距離數組dis，將dis數組初始化為無窮大，將第一個點的距離置為0。

2.循環n - 1次是因為n個點只需添加n - 1個點到集合S，每做一次循環添加一個點，所以是循環n - 1次。

3.標記新點加入集合用一個st數組記錄即可。

4.dis[i]表示的是起點s到i的點距離，所以用新點a去更新起點s到其他點（例如b點）的最短路徑就是比較dis[a] + (a到b的距離）和 dis[b]的大小，將dis[b]置成兩者中的最小值。

5.可以注意的是在偽代碼中的2步：找出距離起點最近的點，要遍歷剩下的所有點，所以時間復雜度是O(n)，但是我們聯想到，在一堆數字中找出一個最小值，可以用堆進行優化，時間復雜度是可以由O（n）降到O（logn）的。所以這就是dijkstra的堆優化，可以將時間復雜度為O（mn）降為O（mlogn）。但是在稀疏圖中使用較好。稠密圖依舊是朴素的dijkstra算法效果更好。

完整代碼：

朴素版本：

時間復雜度O（mn）

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

using namespace std;

const int N = 510;

int n, m;
int g[N][N];
int dis[N];
bool st[N];

int dijkstra()
{
    memset(dis, 0x3f, sizeof dis);//初始化
    dis[1] = 0;

    for (int i = 0; i < n - 1; 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;//標記加入集合S

        for (int j = 1; j <= n; j ++ )//用該點去更新其他點
            dis[j] = min(dis[j], dis[t] + g[t][j]);

    }

    if (dis[n] == 0x3f3f3f3f) return -1;
    return dis[n];
}

int main()
{
    cin >> n >> m;

    memset(g, 0x3f, sizeof g);
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;

        g[a][b] = min(g[a][b], c);
    }

    cout << dijkstra() << endl;

    return 0;
}

    

堆優化版本：

時間復雜度O（mlogn）

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

using namespace std;

typedef pair<int, int> PII;

const int N = 1e5 + 10;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

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

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);//初始化
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;//小根堆
    heap.push({0, 1});//第一個參數是距離，第二個參數是編號
　　//　注意這里st[1]不能置成true，這樣在下面的循環內，1號點就不能拓展，所以我們總是在拿出的時候將st置成true
    while (heap.size())
    {
        PII t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        if (st[ver]) continue;//如果已經加入集合過就跳過
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    cin >> n >> m;

    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }

    cout << dijkstra() << endl;

    return 0;
}