算法導論-單源最短路徑-Dijkstra算法的實現

public class Dijkstra {
    static int M=10000;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] weight1 = {
                {0,3,2000,7,M},
                {3,0,4,2,M},
                {M,4,0,5,4},
                {7,2,5,0,6},    
                {M,M,4,6,0}
        };
        //有向圖的矩陣表示，數值表示權重
        int[][] weight2 = {
                {0,10,M,30,100},
                {M,0,50,M,M},
                {M,M,0,M,10},
                {M,M,20,0,60},
                {M,M,M,M,0}
        };
        int start=0;	//起點s
        int[] shortPath = Dijsktra(weight2,start);
        
        for(int i = 0;i < shortPath.length;i++)
             System.out.println("從"+start+"出   發到"+i+"的最短距離爲："+shortPath[i]);  
          
    }
    
    public static int[] Dijsktra(int[][] weight,int start){
        //接受一個有向圖的權重矩陣，和一個起點編號start（從0編號，頂點存在數組中）
        //返回一個int[] 數組，表示從start到它的最短路徑長度
        int n = weight.length;        //頂點個數
        int[] shortPath = new int[n];    //存放從start到其他各點的最短路徑
        String[] path=new String[n]; //存放從start到其他各點的最短路徑的字符串表示
         for(int i=0;i< n;i++)
             path[i]=new String(start+"-->"+i);
        int[] visited = new int[n];        //標記當前該頂點的最短路徑是否已經求出,1表示已求出
        
        //初始化，第一個頂點求出
        shortPath[start] = 0;
        visited[start] = 1;
        for(int count = 1;count <= n - 1;count++)        //要加入n-1個頂點
        {
 
            int k = -1;    //選出一個距離初始頂點start最近的未標記頂點
            int dmin = Integer.MAX_VALUE;
            for(int i = 0;i < n;i++)
            {
                if(visited[i] == 0 && weight[start][i] < dmin)
                {
                    dmin = weight[start][i];
                   
                    k = i;
                }  
                    
            }
             
            //將新選出的頂點標記爲已求出最短路徑，且到start的最短路徑就是dmin
            shortPath[k] = dmin;
            visited[k] = 1;
  
            //以k爲中間點，修正從start到未訪問各點的距離。每有一個新結點被訪問，便要修正，根據是最短路徑的最優子結構性質
            for(int i = 0;i < n;i++)
            {                 
                if(visited[i] == 0 && weight[start][k] + weight[k][i] < weight[start][i]){
                     weight[start][i] = weight[start][k] + weight[k][i];
                   
                     path[i]=path[k]+"-->"+i;
                 
                }
                
            }  
     
        }
         for(int i=0;i< n;i++)
           System.out.println("從"+start+"出發到"+i+"的最短路徑爲："+path[i]);  
         System.out.println("=====================================");
      
        return shortPath;
    }
}

根據迪傑斯特拉算法的原理，簡單用C語言實現：

#include <iostream>

using namespace std;

#define M 10000

void Dijsktra(int weight[][5], int start);


int dis[5];
int used[5]={0,0,0,0,0};

int main()
{
    int weight2[][5]={
        {0,10,M,30,100},
        {M,0,50,M,M},
        {M,M,0,M,10},
        {M,M,20,0,60},
        {M,M,M,M,0}
    };
    int start=0;
    Dijsktra(weight2, start);

    for(int i=0;i<5;i++)
        cout<<dis[i]<<endl;


    return 0;
}

void Dijsktra(int weight[][5], int start)
{
    int k;

    for(int i=0;i<5;i++)
        dis[i]=weight[start][i];
    for(int i=1;i<5;i++)
    {
        int tmin = M;
        for(int j=1;j<5;j++)
        {
            if(!used[j] && dis[j]<tmin)
            {
                tmin=dis[j];
                k=j;
            }
        }
        used[k]=1;
        for(int j=1;j<5;j++)
        {
            if(dis[k]+weight[k][j] < dis[j])
                dis[j] = dis[k]+weight[k][j];
        }
    }


}

參考2用C語言重新實現了Dijkstra算法，原作者的C語言寫的不錯，值得我學習。我根據其代碼做了輕微的修改，使之更加簡練。這裏把源代碼貼出來，便於以後複習。

#include<stdio.h>
#include<stdlib.h>
#define max 9999
void Dijkstra(int ,int,int *,int *,int **);
void Search(int,int,int*);
int main()
{
    int i,j,num,v,last;//num表示點的個數，v表示起始點；
    FILE *p;
    //2.txt中第一個數據表示點的個數，第二個數據表示起始點；
    //其他數據爲圖中點之間的可達關係，-1表示不可達
    p=fopen("a.txt","r");
    if(!p)
    {
        printf("cannot open file 2.txt");
        exit(0);
    }
    fscanf(p,"%d",&num);//獲得點的個數
    printf("請輸入起始點：");
    scanf("%d",&v);
    int *d=(int*)malloc(sizeof(int)*num);
    //prev[]用於記錄最短路徑中每個點的前一個點
    int *prev=(int *)malloc(sizeof(int)*num);
    //a[][]用於記錄各個點之間的路徑，-1表示不可直達，具體數據參見a.txt；
    int **a=(int**)malloc(sizeof(int*)*num);
    for(i=0;i<num;i++)
        a[i]=(int*)malloc(sizeof(int)*num);
    for(i=0;i<num;i++)
        for(j=0;j<num;j++)
            fscanf(p,"%d",&a[i][j]);

    Dijkstra(v,num,prev,d,a);
    printf("請輸入需要達到的終點(不大於%d): ",num-1);
    scanf("%d",&last);
    if(d[last]==max){}
    else
        printf("起始點%d到達終點%d的路徑長度爲：%d\n",v,last,d[last]);
    Search(v,last,prev);

    return 0;
}
void Dijkstra(int v,int num,int *prev,int *d,int **a)
{
    //d[]用於記錄起始點到達終點的最短路徑
    //s[]用於記錄節點是否已經加入到S（S:已經求的的最短路徑的終點的集合）
    //prev[i]用於記錄從起始節點開始到達i節點的最短路徑中i節點的前一個節點
    int i,j;
    int *s=(int*)malloc(sizeof(int)*num);//s[i]=1表示i點已經爲S中的點；
    for(i=0;i<num;i++)//初始化的d[],s[],prev[];
    {
        s[i]=0;
        d[i]=a[v][i];
        if(d[i]<max)
            prev[i]=v;
        else prev[i]=-1;
    }
    d[v]=0;
    s[v]=1;
    for(i=1;i<num;i++)
    {
        int dmin=max;
        int k;
        for(j=0;j<num;j++)//得出一個V-S中的節點放入到S中。
            if((!s[j])&& d[j]<dmin)//找到d[]最小的點。。。
            {
                k=j;
                dmin=d[j];
            }
            s[k]=1;//k節點放入S中
        for(j=0;j<num;j++)//更新d[]和prev[]
        {
            if((!s[j])&& d[k]+a[k][j]<d[j])
            {
                d[j]=d[k]+a[k][j];
                prev[j]=k;
            }
        }
    }
}
//Search函數主要利用prev[]得出節點v到節點last的最短路徑上的點，
//prev[]的值在Dijkstra函數中已經得到，，，，
void Search(int v,int last,int*prev)
{
    if(prev[last]==-1)
    {
        printf("起始點%d不可達終點%d  \n",v,last);
        exit(0);
    }
    else
    {
        printf("起始點點%d到達終點%d的路徑爲： ",v,last);
        while(last!=v)
        {
            printf("%d <--", last);
            last = prev[last];
        }
        printf("%d\n",v);

    }

}

參考1：http://www.java3z.com/cwbwebhome/article/article1/1341.html?id=4645

參考2：http://www.cnblogs.com/lpshou/archive/2012/04/20/2459102.html