前面轉了兩篇部落格說了一下這個迪傑斯特拉演算法，現在自己嘗試總結一下。

先上一個百度百科的定義：迪傑斯特拉演算法

--------------------------------------------------------------------------------------------------------分割線----------------------------------------------------------------------------------------------------------------

首先，迪傑斯特拉演算法是用來解決單源最短路經問題的,主要是通過邊的鬆弛來實現。

我們來看這個問題：

這個問題求得是從1號頂點到達所有其他頂點的最短距離，我們用鄰接矩陣來儲存這個圖，如下：

我們用一個dis陣列來儲存從一號頂點到其他各個頂點的初始路徑，如圖

先找一個離一號頂點最近的頂點，通過dis我們知道最近的頂點是2號頂點，從第2個頂點有兩條邊是2-->3和2-->4。先通過2-->3這個邊看能否是從1到3的路程變短，也就是比較dis[3]與dis[2]+map[2][3]的大小，很明顯dis[3]=12,而dis[2]+map[2][3]=10,所以我們把dis[3]的值更新為10，這個過程就是我們所說的“鬆弛”，同樣對於2-->4,dis[4]的初始值為無窮大，而dis[2]+dis[2][4]=4,所以我們把dis[4]的值鬆弛為4，經過這一個鬆弛後，dis變成了：

把已經找過的點進行標記，然後在剩下的3,4,5,6頂點鐘找出離1號頂點最近的頂點，很明顯最近的是4，然後根據上面的思路繼續進行鬆弛，一直鬆弛到邊完，這時dis變為

整個過程用完整的程式碼來表示如下：

#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=1<<29;
int main()
{
    int map[10][10],t1,t2,t3,min,u,n,m;
    int dis[10];
    int vis[10];
    scanf("%d%d",&n,&m);
    //初始化
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            if(i==j)
                map[i][j]=0;
            else
                map[i][j]=inf;
    //讀入邊
    for(int i=1; i<=m; i++)
    {
        scanf("%d%d%d",&t1,&t2,&t3);
        map[t1][t2]=t3;
    }
    //初始化dis陣列，表示1號頂點到其餘各個頂點的最短路程
    for(int i=1; i<=n; i++)
        dis[i]=map[1][i];
    //初始化vis
    for(int i=1; i<=n; i++)
        vis[i]=0;
    vis[1]=1;//標記起始點1已經被訪問過
    //迪傑斯特拉演算法(Dijkstra)的核心內容
    for(int i=1; i<=n-1; i++) //因為鬆弛的是邊數，所以是n-1
    {
        min=inf;
        for(int j=1; j<=n; j++)
        {
            if(vis[j]==0&&dis[j]<min)
            {
                min=dis[j];
                u=j;
            }
        }
        vis[u]=1;
        for(int v=1; v<=n; v++)
            if(map[u][v]<inf)
                if(dis[u]+map[u][v]<dis[v])
                    dis[v]=dis[u]+map[u][v];
    }
    for(int i=1;i<=n;i++)
        printf("%d ",dis[i]);
    return 0;
}
 

輸入：

6 9
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 15
5 6 4

0 1 8 4 13 17

利用鄰接表，我們可以把時間複雜度優化到O(M+N)logN,以下是用鄰接表來優化這個演算法的程式碼：

#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=0x3f3f3f3f;
int u[10],v[10],w[10],first[10],next[10],dist[10],vis[10],n,m,k,minn;
int main()
{
    scanf("%d%d",&n,&m);
    //初始化
    for(int i=1; i<=n; i++)
        first[i]=-1;
    //讀入邊
    mem(dist,inf);
    for(int i=1; i<=m; i++)
    {
        scanf("%d%d%d",&u[i],&v[i],&w[i]);
        next[i]=first[u[i]];
        first[u[i]]=i;
        if(u[i]==1)
            dist[v[i]]=w[i];//初始化dis陣列，表示1號頂點到其餘各個頂點的最短路程
    }
    //初始化vis
    for(int i=1; i<=n; i++)
        vis[i]=0;
    vis[1]=1;//標記起始點1已經被訪問過
    dist[1]=0;
    //迪傑斯特拉演算法(Dijkstra)的核心內容
    for(int i=1; i<=n-1; i++)
    {
        minn=inf;
        for(int j=1; j<=n; j++)
        {
            if(vis[j]==0&&dist[j]<minn)
            {
                minn=dist[j];
                k=j;
            }
        }
        vis[k]=1;
        for(int l=first[k]; l!=-1; l=next[l])
        {
            if(w[l]<inf)
                if(dist[k]+w[l]<dist[v[l]])
                    dist[v[l]]=dist[k]+w[l];
        }
    }
    for(int i=1; i<=n; i++)
        printf("%d ",dist[i]);
    return 0;
}