public class Short {
 public static void main(String args[]){
 
  int n = 5;
  int[] prev = new int[n+1];
  int[] dist = {0,0,5000,5000,5000,5000};
  int[][] c = {{0,0,0,0,0,0},{0,0,2,3,5000,5000},
    {0,5000,0,1,2,5000},{0,5000,5000,0,9,2},
    {0,5000,5000,5000,0,2},{0,5000,5000,5000,5000,0}};
  /*
  int n = 4;
  int[] dist = {0,0,5000,5000,5000};
  int[][] c = {{0,0,0,0,0},{0,0,2,3,5000},{0,5000,0,1,2},{0,5000,5000,0,9},{0,5000,5000,5000,0}};
  
  */

  Graph g = new Graph(n,prev,c,dist);
  g.shortestPath(1);
  System.out.println(dist[n]);
 }
 
}

class MinHeapNode{

 int i;    //頂點編號
 int length;   //當前路長

}
//迴圈佇列
class CirQueue{
  int size = 5000;    //定義佇列長度為1000
  int front,rear;
  MinHeapNode data[] = new MinHeapNode[size];

  public CirQueue(){
   front = rear = 0;
  }
  
  //元素入隊操作
  void queryIn(MinHeapNode e){
   
   if((rear +1)%size == front){
    System.out.println("佇列已滿");
   }else{
    rear = (rear+1)%size; //隊尾指標在迴圈意義下加1
    data[rear] = e;   //在隊尾插入元素
    
   }
  }
  
  
  //元素出隊操作
  MinHeapNode queryOut(){
   if(rear == front){
    System.out.println("佇列已空");
    return null;
   }else{
    front = (front+1)%size;  //佇列在迴圈意義下加1
    return data[front];
   }
  }
  //讀取隊頭元素，但不出隊
  MinHeapNode getQuery(){
   if(rear == front){
    System.out.println("佇列已空");
    return null;
   }else{
    return data[(front+1)%size];
   }
  }
  
  
  //判斷佇列是否為空
  boolean empty(){
   return front == rear;
   
  }
 }

//圖的表示
class Graph{
 static int inf = 5000;   //兩點距離上界
 int n;       //圖的頂點個數
 int prev[];      //圖的前驅頂點
 int c[][];      //圖的鄰接矩陣
 int dist[];      //最短距離陣列
 public Graph(int n,int[] prev,int[][] c,int[] dist){
  
  this.n = n;
  this.prev = prev;
  this.c = c;
  this.dist  = dist;
 }
 
 /**
  * 單源最短路徑問題的優先佇列式分支限界法
  */
 
 public void shortestPath(int v){
  //建立佇列
  CirQueue qq = new CirQueue();
  
  //定義源為初始擴充套件結點
  MinHeapNode e = new MinHeapNode();
  e.i = v;
  e.length = 0;
  dist[v] = 0;
  qq.queryIn(e);
  //搜尋問題的解空間
  while(true){
   for(int j = 1;j<=n;j++){
    
    if(j>n){
     break;
    }
    MinHeapNode m = qq.getQuery();
    if((c[m.i][j]<inf)&&(m.length + c[m.i][j] < dist[j])){
     
     //頂點i到頂點j可達，且滿足控制約束
     dist[j] = m.length + c[m.i][j];
     prev[j] = m.i;
    
    //加入活結點優先佇列
    MinHeapNode mi = new MinHeapNode();
    mi.i = j;
    mi.length  = dist[j];
    
    qq.queryIn(mi);   //元素入隊
    }
   }//for迴圈結束
   
   
   qq.queryOut();    //當該結點的孩子結點全部入隊後，刪除該結點
   
   if(qq.empty()){    //當佇列為空時，演算法結束
    break;
   }
  }//while迴圈結束
 }
}