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