java实现两点最小代价路线方案

由起点遍历最近点，再把该最近点看作一个新的起点去计算到终点的最小代价，以此类推通过迭代算出，最后返回最优方案和总代价。

点与点之间的代价也就是连线由数组来描述

如：distance[0][3]=1表示0点到3点距离为1

代码：

import java.util.Scanner;
class ShortDis
{
    int[][] distance={  //记录点与点之间的距离，0表示自已或两点之间没有直接边线
     {0,2,4,1,0,0,4,0},
     {2,0,1,0,3,0,0,0},
     {4,1,0,0,5,6,0,0},
     {1,0,0,0,3,0,9,0},
     {0,3,5,3,0,0,0,6},
     {0,0,6,0,0,0,2,8},
     {4,0,0,9,0,2,0,2},
     {0,0,0,0,6,8,2,0}
    };
    int[] select={0,0,0,0,0,0,0,0};  //描述点是否被选择，0表示没有被选中，1表示被选中
    public static void main(String[] args)
    {
        Scanner input=new Scanner(System.in);
        ShortDis shortdis=new ShortDis();
        int sel;
        do{
        System.out.println("请选择功能：1、录入图象距离  2、显示距离二维数组   3、计算两点最短距离");
        sel=input.nextInt();
        switch(sel){
          case 1:
           shortdis.selectEnter(input);
           break;
          case 2:
           shortdis.showDistance();
          break;
          case 3:
          System.out.println("输入两个数不大于7，用空格隔开");
          int num1=input.nextInt();
          int num2=input.nextInt();
          Disitem item= shortdis.calculation(num1,num2);
          System.out.println("最佳路线为："+item.path);
          System.out.println("最短距离为："+item.shortdistance);
          break;
        }
        }while(sel!=-1);
    }
    public void selectEnter(Scanner input){
        int a;
        int b;
        do{
        System.out.println("分别输入两点名称，用空格隔开，用数字代替(-1退出)");
        a=input.nextInt();
        if(a==-1){
          break;
        }
        b=input.nextInt();
        System.out.println("输入距离：");
        int dis=input.nextInt();
        distance[a][b]=dis;
        distance[b][a]=dis;
        }while(a!=-1);
    }
    public void showDistance(){
       for(int i=0;i<8;i++){
         for(int j=0;j<8;j++){
           System.out.print(distance[i][j]+" ");
         }
         System.out.println();
       }
    }
    public Disitem calculation(int a,int b){
       Disitem disitem=new Disitem();
       if(a==b){  //表示迭代到终点了，返回0，并返回该点
        disitem.shortdistance=0;
        disitem.path=b+"";
       }else{
       for(int i=0;i<8;i++){
         if(distance[a][i]!=0){
           if(select[a]==0){
            select[a]=1; //锁定该点
            Disitem lsitem=calculation(i,b);  //迭代计算
            int curdis=distance[a][i]+lsitem.shortdistance;
            select[a]=0;  //释放点
            if(curdis<disitem.shortdistance){ //如果比当前代价小，则保存值
              disitem.shortdistance=curdis;
              disitem.path=a+","+lsitem.path;
            }
          }
         }
       }
       }
       return disitem;
    }
}
class Disitem  //返回类，一个表示最低代价，一个表示路径
{
    int shortdistance=100;
    String path;
}

运行效果：