Dijkstra演算法是典型的演算法。Dijkstra演算法是很有代表性的演算法。Dijkstra一般的表述通常有兩種方式，一種用永久和臨時標號方式，一種是用OPEN, CLOSE表的方式，這裡均採用永久和臨時標號的方式。注意該演算法要求圖中不存在負權邊。
　　
　　微軟程式設計比賽裡面的一道難度係數5%的程式設計題目如下：


　　Dijkstra演算法是用來求解圖中頂點到另外其他頂點的最短路徑的，根據題目，我們可以把每兩個島嶼往來所花的最少金幣當成圖中的邊權值，由此可以用Dijkstra演算法來解決這個問題。

　　根據圖來建立權值矩陣：
int[][] W = {
{ 0, 1, ５, -1, -1, -1，-1，-1 ，-1},
{ 1, 0, 3, 7, 5, -1，-1，-1，-1},
{ 5, 3, 0, -1, 1, 7, -1，-1，-1，-1 },
{ -1, 7, -1, 0, 2, -1,3，-1，-1 },
{ -1, 5, 1, 2, 0, 3, 6, 9，-1},
{-1，-1，-1, 3，6，-1, 0， 2, 7}
{-1，-1，-1，-1，9，5，2, 0, 4}
{-1，-1，-1，-1，-1，-1, 7, 4, 0}
};(-1表示兩邊不相鄰,權值無限大)

java程式碼如下：

package wxt;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

//這個演算法用來解決無向圖中任意兩點的最短路徑  
public class Dijkstra {
  public static int dijkstra(int[][] W1, int start, int end) {  
      boolean[] isLabel = new boolean[W1[0].length];// 是否標號  
      int[] indexs = new
 
 int[W1[0].length];// 所有標號的點的下標集合，以標號的先後順序進行儲存，實際上是一個以陣列表示的棧  
      int i_count = -1;//棧的頂點  
      int[] distance = W1[start].clone();// v0到各點的最短距離的初始值  
      int index = start;// 從初始點開始
      int presentShortest = 0;//當前臨時最短距離  

      indexs[++i_count] = index;// 把已經標號的下標存入下標集中  
      isLabel[index] = true;  

      while
 
 (i_count<W1[0].length) {  
          // 第一步：標號v0,即w[0][0]找到距離v0最近的點  

          int min = Integer.MAX_VALUE;  
          for (int i = 0; i < distance.length; i++) {  
              if (!isLabel[i] && distance[i] != -1 && i != index) {  
                  // 如果到這個點有邊,並且沒有被標號  
                  if (distance[i] < min) {  
                      min = distance[i];  
                      index = i;// 把下標改為當前下標  
                  }  
              }  
          }  
          if (index == end) {//已經找到當前點了，就結束程式  
              break;  
          }  
          isLabel[index] = true;//對點進行標號  
          indexs[++i_count] = index;// 把已經標號的下標存入下標集中  
          if (W1[indexs[i_count - 1]][index] == -1 
                  || presentShortest + W1[indexs[i_count - 1]][index] > distance[index]) {  
              // 如果兩個點沒有直接相連，或者兩個點的路徑大於最短路徑  
              presentShortest = distance[index];  
          } else {  
              presentShortest += W1[indexs[i_count - 1]][index];  
          }  

          // 第二步：將distance中的距離加入vi  
          for (int i = 0; i < distance.length; i++) {  
              // 如果vi到那個點有邊，則v0到後面點的距離加  
              if (distance[i] == -1 && W1[index][i] != -1) {// 如果以前不可達，則現在可達了  
                  distance[i] = presentShortest + W1[index][i];  
              } else if (W1[index][i] != -1 
                      && presentShortest + W1[index][i] < distance[i]) {  
                  // 如果以前可達，但現在的路徑比以前更短，則更換成更短的路徑  
                  distance[i] = presentShortest + W1[index][i];  
              }  

          }  
      }  
      //如果全部點都遍歷完，則distance中儲存的是開始點到各個點的最短路徑  
      return distance[end] - distance[start];  
  }  
  private static class Island{
      public int x,y;
  }
  public static void main(String[] args) {  
      ArrayList<Island> arr=new ArrayList<Island>();
      // 建立一個權值矩陣  

      int [][] Test={
              {0,1,4},{1,0,1},{4,1,0}
      };
      Scanner input=new Scanner(System.in);
      int num=input.nextInt();
      for (int i = 0; i < num; i++) {
          Island island=new Island();
          island.x=input.nextInt();
          island.y=input.nextInt();
          arr.add(island);
    }
      int [][] t=new int[num][num];
      for (int i = 0; i < t.length; i++) {
          for (int j = 0; j < t.length; j++) {
            t[i][j]=Math.min(Math.abs(arr.get(i).x-arr.get(j).x), Math.abs(arr.get(i).y-arr.get(j).y));
        }

    }
      System.out.println(dijkstra(t, 0,num-1));  

  }  
}