DIJKSTRA算法-java实现

曾经上实验课的时候，写了一个dijkstra算法，如今继续让自己回顾一下：

作业要求：

最短路径问题求解

实验目的：

以最短路径问题为例，掌握动态规划的基本设计策略；

利用dijkstra贪心法求解最短路径问题并实现；

利用动态规划方法Floyd算法求解最短路径问题并实现；

package com.coffee.DIJKSTRA;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class MyTest3 {
	private HashSet<Integer> N;// 存放各个点的名字
	private HashSet<Integer> S;// 已经确定最短距离的集合
	private HashSet<Integer> VS;// V-{S}; V-S中包括尚未确定最短路径的顶点
	private ArrayList<Integer> D; // 存放源点 v1 到 vi 的最短路径
	private int [][]juli;    //floyd 所需要的最后的距离矩阵
	
	private int[][] graph = new int[][] {
			{ 0,0, 0, 0, 0, 0, 0, },
			{ 0,0, 0, 15, 0, 0, 0 }, 
			{ 0,2, 0, 0, 0, 10, 30 },
			{ 0,0, 4, 0, 0, 0, 10 }, 
			{ 0,0, 0, 0, 0, 0, 0 }, 
			{ 0,0, 0, 0, 15, 0, 0 },
			{ 0,0, 0, 0, 4, 10, 0 }, };//便于后面算法后标记的利用，将第一列和第一行置为0；让角标从1开始
	
	
	//实验问题1
	//将dijkstra算法封装，传入源点
	public void Dijkstra(int s){
		initDate(s);
		dijkstra();
	}
	
	//实验问题2
	//方法1 循环 调用dijkstra 方法 求出两点之间的最短距离 
	public void minRodeinPerNode(){
		for(int i=1;i<=6;i++){
			Dijkstra(i);
			System.out.println("点"+i+"到各个点的距离：");
			printDVS();
		}
	}
	
	//实验问题3
	//方法2 计算完全最短路径的floyd 算法
	public void floyd(){
		//1得到权重矩阵 就是图的淋接矩阵
		juli = graph;  	
		//2将权重矩阵的0全部改为max
		for(int i=1;i<juli.length;i++){
			for(int j=1;j<juli.length;j++){
				if(juli[i][j]==0){
					juli[i][j]=Integer.MAX_VALUE;
					if(i==j){
						juli[i][j]=0;
					}
				}
			}
		}
		
		for(int k=1;k<juli.length;k++){//k  1-6  D(1)-D(6)  
			for(int i=1;i<juli.length;i++){
				for(int j=1;j<juli.length;j++){
					//核心代码 juli[i,j]=min(juli[i,k]+juli[k,j],juli[i,j] )
					juli[i][j]=minjuli(i,j,k);
				}
			}
		}
		
	}
	public int minjuli(int i, int j, int k) {
		int add = juli[i][k]+juli[k][j];
		//最大值 再加一个值就会越界 所以加上一个判定add>0；
			if(add>0 && add<juli[i][j]){
				return add;
			}else
			return juli[i][j];
	}

	
	//初始化，传入原点
	public void initDate(int s) {
		int name[] = { 1, 2, 3, 4, 5, 6 };// 存放各个顶点的名称
		// 初始化各个点的名字
		N = new HashSet<Integer>();
		for (int i = 0; i < 6; i++) {
			N.add(name[i]);
		}
		VS = new HashSet<Integer>(N);// 集合vs初始化  将集合N放入VS
		S = new HashSet<Integer>();
		//添加源点1到S中，再讲未求得最短路径的点中减去1
		S.add(s);
		VS.remove(s); // 将源点放入源集合中， 将v-s中减去点1；
		//初始化最短路径向量
		D = new ArrayList<>(7);
		for (int i = 0; i <7; i++) {
			D.add(Integer.MAX_VALUE);// 将集合D中的所有点初始化为无穷
		}
		D.set(s, 0);// 将d中源点V1到V1的点的距离初始化为0;
		for(int y = 1 ; y<=N.size();y++){
			 if(graph[s][y]>0)
				 D.set(y,length(s, y));
			 else
				 D.set(y, Integer.MAX_VALUE);}
	}
	public void dijkstra(){  
		  for(int i=1;i<=N.size();i++){
			  int min = findMininD();//返回点的名字
			  //将 VS中减取此点 源点集合中增加此点
			  S.add(min);
			  VS.remove(min);
		 /*    System.out.print("第"+i+"次：");
		     printDVS();
		     System.out.println("min:"+min);*/
			  //然后根据此点 算得此点到VS中每个点的最短路径的距离顶点的距离 
			  //去比较 V1到 VS中的 D中的最短距离 取最小修改到D中
			for(int j=1;j<graph.length;j++){  
				if(graph[min][j]>0){
				//核心算法
					if(VS.contains(j) && (D.get(min)+length(min,j)<D.get(j)))
					D.set(j, (D.get(min)+length(min, j)));
				}
			}
		  }
	  }
	
	public int length(int x,int y){
		if(graph[x][y]>0){
			return graph[x][y];
		}else{
			return Integer.MAX_VALUE;
		}
	}

    //打印图的信息
    public void printtable() {
       System.out.println("");
       System.out.println("图的信息:");
       for (int i = 1; i < graph.length; i++) {
           for (int j = 1; j < graph.length; j++) {
              System.out.printf("%3d", graph[i][j]);
           }
           System.out.println();
       }
    }
    //打印距离矩阵图的信息
    public void printjuli() {
        System.out.println();
        System.out.println("距离矩阵:");
        for (int i = 1; i < juli.length; i++) {
            for (int j = 1; j < juli.length; j++) {
            	if(juli[i][j]==Integer.MAX_VALUE){
            		System.out.print("	Max");
            	}else
               System.out.print("	"+juli[i][j]);
            }
            System.out.println();
        }
     }

    //比较v1到各个未算得最短路径的点的距离 选择最小的一个点返回
	public int findMininD() {
		//对D中进行迭代，寻找出VS中有的且最小的
		Iterator<Integer> it = D.iterator();
		int temp =Integer.MAX_VALUE;
		while(it.hasNext()){
			int value = it.next();//取得 i到 各个点 最小路径得长度
			//关键条件：
			if(VS.contains(D.indexOf(value)) && value<=temp){ //vs中要有，d中最大
				temp=value;
			}
		}
		return D.indexOf(temp);//返回名字
	}
	public void printDVS(){
	
		for(int i=1;i<D.size();i++){
			if(D.get(i)==Integer.MAX_VALUE){
			System.out.print("Max  ");
			}else
			System.out.print(D.get(i)+" ");
		}
		System.out.println();
		System.out.print("S：");
		Iterator it = S.iterator();
		while(it.hasNext()){
			System.out.print(it.next()+" ");
		}
		System.out.println();
		System.out.print("V-S  ：");
		Iterator it2 = VS.iterator();
		while(it2.hasNext()){
			System.out.print(it2.next()+" ");
		}
		System.out.println();
		
	}
	
	public static void main(String[] args) {
		MyTest3 test3 = new MyTest3();
		test3.minRodeinPerNode();
		test3.floyd();
		test3.printjuli();
	}
}