轉載自：http://www.cnblogs.com/dolphin0520/archive/2011/08/26/2155202.html

動畫演示：http://www.ntnoi.cn/FLASH/arithmetic/2010-05-17/23.html    http://baike.baidu.com/view/1712262.htm

 單源最短路徑問題，即在圖中求出給定頂點到其它任一頂點的最短路徑。在弄清楚如何求算單源最短路徑問題之前，必須弄清楚最短路徑的最優子結構性質。

一.最短路徑的最優子結構性質

   該性質描述為：如果P(i,j)={Vi....Vk..Vs...Vj}是從頂點i到j的最短路徑，k和s是這條路徑上的一箇中間頂點，那麼P(k,s)必定是從k到s的最短路徑。下面證明該性質的正確性。

   假設P(i,j)={Vi....Vk..Vs...Vj}是從頂點i到j的最短路徑，則有P(i,j)=P(i,k)+P(k,s)+P(s,j)。而P(k,s)不是從k到s的最短距離，那麼必定存在另一條從k到s的最短路徑P'(k,s)，那麼P'(i,j)=P(i,k)+P'(k,s)+P(s,j)<P(i,j)。則與P(i,j)是從i到j的最短路徑相矛盾。因此該性質得證。

二.Dijkstra演算法

   由上述性質可知，如果存在一條從i到j的最短路徑(Vi.....Vk,Vj)，Vk是Vj前面的一頂點。那麼(Vi...Vk)也必定是從i到k的最短路徑。為了求出最短路徑，Dijkstra就提出了以最短路徑長度遞增，逐次生成最短路徑的演算法。譬如對於源頂點V0，首先選擇其直接相鄰的頂點中長度最短的頂點Vi，那麼當前已知可得從V0到達Vj頂點的最短距離dist[j]=min{dist[j],dist[i]+matrix[i][j]}。根據這種思路，

假設存在G=<V,E>，源頂點為V0，U={V0},dist[i]記錄V0到i的最短距離，path[i]記錄從V0到i路徑上的i前面的一個頂點。

1.從V-U中選擇使dist[i]值最小的頂點i，將i加入到U中；

2.更新與i直接相鄰頂點的dist值。(dist[j]=min{dist[j],dist[i]+matrix[i][j]})

3.知道U=V，停止。

演算法步驟：

在儲存路徑的時候，參考程式中的方法，對每一次修改了最小距離的頂點進行記錄，然後使用頂點之間的跳轉進行索引。

/*Dijkstra求單源最短路徑*/

#include <iostream>
#include<stack>
#include<stdlib.h>
#include <stdio.h>
#include<limits.h>
#define M 100
#define N 100
using namespace std;

typedef struct node
{
    int matrix[N][M];      //鄰接矩陣
    int n;                 //頂點數
    int e;                 //邊數
}MGraph;

void DijkstraPath(MGraph g,int *dist,int *path,int v0)   //v0表示源頂點
{
    int i,j,k;
    bool *visited=(bool *)malloc(sizeof(bool)*g.n);
    for(i=0;i<g.n;i++)     //初始化
    {
        if(g.matrix[v0][i]>0&&i!=v0)
        {
            dist[i]=g.matrix[v0][i];
            path[i]=v0;     //path記錄最短路徑上從v0到i的前一個頂點
        }
        else
        {
            dist[i]=INT_MAX;    //若i不與v0直接相鄰，則權值置為無窮大
            path[i]=-1;
        }
        visited[i]=false;
        path[v0]=v0;
        dist[v0]=0;
    }
    visited[v0]=true;
    for(i=1;i<g.n;i++)     //迴圈擴充套件n-1次
    {
        int min=INT_MAX;
        int u;
        for(j=0;j<g.n;j++)    //尋找未被擴充套件的權值最小的頂點
        {
            if(visited[j]==false&&dist[j]<min)
            {
                min=dist[j];
                u=j;
            }
        }
        visited[u]=true;    //加入已經訪問過的集合，被訪問過的集合裡的點的距離都是到原點距離最近的
        for(k=0;k<g.n;k++)   //更新dist陣列的值和路徑的值
        {
            //當訪問過集合變化的時候，看一下這個集合中新頂點相鄰點到原點的距離是否縮短了
            if(visited[k]==false&&g.matrix[u][k]>0&&(min+g.matrix[u][k])<dist[k])
            {
                dist[k]=min+g.matrix[u][k];
                //路徑有更新就記錄一下這一步加入訪問集合的頂點~~
                path[k]=u;
            }
        }
    }
}

void showPath(int *path,int v,int v0)   //列印最短路徑上的各個頂點
{
    stack<int> s;
    int u=v;
    while(v!=v0)
    {
        s.push(v);
        v=path[v];
    }
    s.push(v);
    while(!s.empty())
    {
        cout<<s.top()<<" ";
        s.pop();
    }
}

int main(int argc, char *argv[])
{
    int n,e;     //表示輸入的頂點數和邊數
    while(cin>>n>>e&&e!=0)
    {
        cout<<"Enter your graph"<<endl;
        int i,j;
        int s,t,w;      //表示存在一條邊s->t,權值為w
        MGraph g;
        int v0;
        int *dist=(int *)malloc(sizeof(int)*n);
        int *path=(int *)malloc(sizeof(int)*n);
        for(i=0;i<N;i++)
            for(j=0;j<M;j++)
                g.matrix[i][j]=0;
        g.n=n;
        g.e=e;
        printf("Enter %d verticeIndex and %d edges\n",n,e);
        for(i=0;i<e;i++)
        {
            cin>>s>>t>>w;
            g.matrix[s][t]=w;
        }
        cout<<
        cin>>v0;        //輸入源頂點
        DijkstraPath(g,dist,path,v0);
        for(i=0;i<n;i++)
        {
            if(i!=v0)
            {
                showPath(path,i,v0);
                cout<<dist[i]<<endl;
            }
        }

    }
    return 0;
}