Dijkstra(迪杰斯特拉)算法

Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

求最短路径步骤　　

算法步骤如下：　　

1. 初使时令 S={V0},T={其余顶点}，T中顶点对应的距离值　　

    若存在，d(V0,Vi)为弧上的权值　　

    若不存在，d(V0,Vi)为∝　

2. 从T中选取一个其距离值为最小的顶点W且不在S中，加入S

3. 对T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的

    距离值比不加W的路径要短，则修改此距离值　　

    重复上述步骤2、3，直到S中包含所有顶点，即S=T为止

package com.minPath;

import java.util.Scanner;

public class DjistraPath {
    public static int cityNum;//行数
    public static int line;
    public static int bigNum=10000;//
    
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        cityNum=scanner.nextInt();
        line=scanner.nextInt();
        int[][] matrix=new int[cityNum][cityNum];
        int[] dist=new int[cityNum];//用于记录0到其他节点的距离
        boolean[] flag=new boolean[cityNum];//用于标记节点是否被访问
        for(int i=0;i             for(int j=0;j                 if(i==j)
                  matrix[i][j]=0;
                else
                  matrix[i][j]=bigNum;    
            }
        for(int k=0;k            int row=scanner.nextInt();
           int col=scanner.nextInt();
           int value=scanner.nextInt();
           matrix[row][col]=value;
        }
       for(int k=0;k            dist[k]=matrix[0][k];
           flag[k]=false;//默认都没有访问    
       }
       for(int k=0;k            System.out.print("  dist"+k+"--"+dist[k]);
       }
       System.out.println();
       int index=0;
       flag[0]=true;//默认第一个点已经访问
       int min;
       for(int i=0;i            min=bigNum;
           for(int w=0;w                if(flag[w]==false){
                   if(dist[w]                        index=w;
                       min=dist[w];
                   }
               }
           }
           System.out.println("index---"+index);
           flag[index]=true;
           System.out.println("pre dist[3]"+dist[3]+" dist[1]"+dist[1]+" matrix[1][3]"+matrix[1][3]);
          for(int j=0;j             if(flag[j]==false && (dist[j]>dist[index]+matrix[index][j])){
                    dist[j]=dist[index]+matrix[index][j];
            }
//            System.out.print("  跟新---dist("+j+")--"+dist[j]);
         }
           System.out.println("pre dist[3]"+dist[3]+" dist[1]"+dist[1]+" matrix[1][3]"+matrix[1][3]);
           System.out.println();
       }    
       System.out.println("----------");
       for(int i=0;i            for(int j=0;j                System.out.print(matrix[i][j]+" ");
               
           }
           System.out.println();
       }
    
       for(int s=1;s            System.out.println("0----->"+s+":"+dist[s]);
       }
    
    }
}

/*
Test Date:
5 7
0 1 3
0 3 8
1 2 5
1 4 4
2 3 4
2 4 7
3 4 2
Out put:
0->1:3
0->2:8
0->3:8
0->4:7
*/