上邊n表示節點個數，m表示邊，其中稠密圖用鄰接矩陣存，稀疏圖用鄰接表來存。

稀疏圖與稠密圖定義：資料結構中對於稀疏圖的定義為：有很少條邊或弧（邊的條數|E|遠小於|V|²）的圖稱為稀疏圖（sparse graph），反之邊的條數|E|接近|V|²，稱為稠密圖（dense graph）。（來自百度百科）

Dijkstra演算法

1.樸素Dijkstra演算法

模板

s陣列：標記當前已經確定最短距離的點
void Dijkstra()
{
      dist[1] = 0, dist[i] =  +$\infty$  //初始化
      for i: 0 ~ n //n個點
            for j；1 ~ n
            t <- 不在s中的，距離最近的點
            st[t] = true; //標記
            for j；1 ~ n
            用t更新其他的點的距離
}
 

例題

給定一個n個點m條邊的有向圖，圖中可能存在重邊和自環，所有邊權均為正值。

請你求出1號點到n號點的最短距離，如果無法從1號點走到n號點，則輸出-1。

輸入格式
第一行包含整數n和m。

接下來m行每行包含三個整數x，y，z，表示存在一條從點x到點y的有向邊，邊長為z。

輸出格式
輸出一個整數，表示1號點到n號點的最短距離。

如果路徑不存在，則輸出-1。

資料範圍
1 ≤ n ≤ 500,
1 ≤ m ≤ 10^5,
圖中涉及邊長均不超過10000。

輸入樣例：
3 3
1 2 2
2 3 1
1 3 4
輸出樣例：
3

首先題目中說明存在重邊和自環，我們用鄰接矩陣來存圖必須要解決這個問題，因此我們做這樣的決策：對於重邊，取最小；對於自環，忽略不計，設為0。

根據上邊稀疏圖與稠密圖定義可知：這是一個稠密圖，因此用鄰接矩陣來存圖

程式碼

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

using namespace std;

const int N = 510;

int n, m;
int g[N][N]; //鄰接矩陣存圖
int dist[N]; //圖中每個點到1的距離
bool st[N]; //表示某個點的最短距離是否被確定

int Dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < n; i++) //確定n個點的最短距離 確定好每個點到起點的最短距離 
    {
        int t = -1;
        for(int j = 1; j <= n; j++) //尋找不在st中 距離最近的點
            if(!st[j] && (t == -1 || dist[t] > dist[j])) //在還沒有確定的點中找到距離1最近的點
                t = j;
        
        for(int j = 1; j <= n; j++)  //用t更新其他點的距離
        { 
            dist[j] = min(dist[j], dist[t] + g[t][j]);  //用1~t+t~j的長度更新1~j的長度
        }

        st[t] = true;  //表示已經t這個點已經確定最短距離
    }

    if(dist[n] == 0x3f3f3f3f) return -1; //表示1與n不連通
    return dist[n];
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(g, 0x3f, sizeof g);
    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;
}
 

2.堆優化Dijkstra演算法

看這個模板

s陣列：標記當前已經確定最短距離的點
void Dijkstra()
{
      dist[1] = 0, dist[i] =  +$\infty$  //初始化
      for i: 0 ~ n //n個點
            for j；1 ~ n
            **t <- 不在s中的，距離最近的點
            st[t] = true; //標記
            for j；1 ~ n
            用t更新其他的點的距離
}

其中加**的那一步，我們尋找最小點的過程遍歷了所有的邊，很費時間，所以我們可以直接用優先佇列定義一個小根堆彈出距離1最小的節點（即堆頂）， 省略了查詢的過程，更新後的節點則重新壓入佇列尾部。

優化後的Dijkstra程式碼：（相比於上題更改了資料範圍，1 ≤ n,m ≤ 1.5×10^5 是一個稀疏圖，因此用鄰接表來存圖）

int Dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap; //建立小根堆
    heap.push({0, 1});   //second是編號 first是距離 因為根據優先佇列會先根據第一個關鍵字排序 因此這樣設定

    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int var = t.second; //記錄編號
        
        if(st[var]) continue; //如果已經確定距離 則continue
        st[var] = true; //標記

        for(int i = h[var]; i != -1; i = ne[i]) //遍歷當前點的所有出邊  因為是稀疏圖用鄰接表來儲存
        {
            int j = e[i];
            if(dist[j] > dist[var] + w[i]) //更新
            {
                dist[j] = dist[var] + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if(dist[n] == 0x3f3f3f3f) return -1; //說明沒被更新
    return dist[n];
}

用鄰接表存圖不需要考慮重邊和自環
總程式碼

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

using namespace std;

typedef pair<int, int> PII; //first表示距離 second表示編號

const int N = 1e6+10;
int n, m;
int h[N], e[N], ne[N], w[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});  

    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int var = t.second; //記錄編號
        
        if(st[var]) continue;
        st[var] = true;

        for(int i = h[var]; i != -1; i = ne[i]) //遍歷當前點的所有出邊
        {
            int j = e[i];
            if(dist[j] > dist[var] + w[i]) //更新
            {
                dist[j] = dist[var] + w[i];
                heap.push({dist[j], j});
            }
        }
    }

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

int main()
{
    scanf("%d%d", &n, &m);
    
    memset(h, -1, sizeof h);

    while(m--)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);

        add(a, b, c);
    }

    printf("%d\n", Dijkstra());

    return 0;
}

未完待續。。