Dijkstra方法求解网络最短路

实验内容：

 

求如图所示的赋权图中, 从到的最短路。

 

JAVA代码：package com.Hyaline;
/**
 * 运筹学实验二：用dijkstra算法求解最短路问题：
 * 步骤：1.先将路线数组初始化，将已有路线的权值添加，其余的赋值 0或1000；
 *     
 *
 */

public class NewShortPath {
    static int M = 100;
    int[] P = new int[9]; //P(v)表示v的P标号
    int[] T = new int[9]; //T(v)表示v的T标号
    int[] S = new int[9]; //S(i)表示第i步时，具P标号的点的集合
    int[] f = new int[9];  //顶点数组,数组里存的数是f
    int[][] path = new int[9][9];
    int k;         //k记录当前进行运算的顶点
    int i, j;
    int local;    //记录当前顶点的编号
    int m = 1;    // 总共步骤
    int fo = 0;    //用于判断当前顶点是否包含在S集中
    int mini;
    String[] point = {"v1","v2","v3","v4","v5","v6","v7","v8","v9"};   //记录各个顶点的名字
    
    //Dijstra算法：
        public void miniPath(){
            k = 0;   //以第一个顶点为起始点（可以任意选择）
            S[0] = 0;
            f[0] = 0;
            
            while(m<9){   //循环直到P(v8)有第一个值
                com_T(k);  //计算所有T标号的值
                mini = miniT();   //求出最小T标号
                P[local] = mini;  //将最小的值赋给P
                S[m] = local;
                k = local;
                S[m] = k;
                m++;
            }
            System.out.print("当前S集中的顶点为：");
            print(S);
        }
        //求最短路径长度
        public void pathLength(int x){ //求初始点到指定点的路径长度
            int lenPath = P[x-1];
            System.out.println("从起点到"+ x +"的最短路径为：" + lenPath);
        }
        //打印
        public void print(int a[]){
            for(int l=0; l<9; l++){
                System.out.print(point[a[l]] + "*****");
            }
            System.out.println();
        }
        //判断顶点是否在S中
        public int notConstains(int x){
            for(int l=0; l<S.length; l++){
                if(S[l]==x) {
                    fo=2; //如果x在S中，则返回false，不计算。
                    return fo;
                }
            }
            fo = 1;
            return fo;
        }
        //求出当前k值下的所有T标号的值
        public void com_T(int k){
            for(int i=0; i<9; i++){
                if(notConstains(i) == 1){
                    if((path[k][i] < M) && (T[i] > P[k] + path[k][i])){
                        T[i] = P[k] + path[k][i];
                        f[i] = k;
                    }
                }
            }
        }
        //求出T标号中的最小值
        public int miniT(){
            mini = 20;
            for(int i=0; i<T.length; i++){
                if((notConstains(i) == 1)&&(mini>T[i])){
                    mini = T[i];
                    local = i;   //记录当前最小值得编号
                }
            }
            return mini;
        }
    
    //初始化路线数组、且添加将已有路线的权值
        public void init(){
            for(i=0; i<path.length; i++){
                for(j=0; j<path.length; j++){
                    if(i == j)
                        path[i][j] = 0;    //某点到自身的距离为0；
                    path[i][j] = M;     //初始化将所有的路线权值均设为1000 表示没有该路
                }
            }
            //无向图，双向赋值
            path[0][1] = path[1][0] = 6;
            path[0][2] = path[2][0] = 3;
            path[0][3] = path[3][0] = 1;
            path[1][2] = path[2][1] = 2;
            path[1][4] = path[4][1] = 1;
            path[2][3] = path[3][2] = 2;
            path[3][4] = path[4][3] = 6;
            path[3][5] = path[5][3] = 10;
            path[4][5] = path[5][4] = 4;
            path[4][6] = path[6][4] = 3;
            path[4][7] = path[7][4] = 6;
            path[4][8] = path[8][4] = 2;
            path[5][6] = path[6][5] = 2;
            path[6][7] = path[7][6] = 4;
            path[7][8] = path[8][7] = 3;
            
            for(i=0; i<9; i++){
                T[i] = M;
                S[i] = M;
                P[i] = 0;
                f[i] = 0;
            }
        }

        public static void main(String[] args) {
            NewShortPath minipath = new NewShortPath();
            minipath.init();
            minipath.miniPath();
            minipath.pathLength(8);
        }
}