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]);
       }
    
    }
}

  1. /* 
  2. Test Date: 
  3. 5 7 
  4. 0 1 3 
  5. 0 3 8 
  6. 1 2 5 
  7. 1 4 4 
  8. 2 3 4 
  9. 2 4 7 
  10. 3 4 2 
  11. Out put: 
  12. 0->1:3 
  13. 0->2:8 
  14. 0->3:8 
  15. 0->4:7 
  16. */

你可能感兴趣的:(算法,java,算法,java)