【回溯-全排列&&dfs】蜜蜂采蜜

题目描述：

一群蜜蜂离开蜂巢采蜜，要连续采集5片花丛后归巢。已知5片花丛相对蜂巢的坐标，请你帮忙规划一下到访花丛的顺序，使飞行距离最短。

输入描述：

以蜂巢为平面坐标原点的5片花丛A，B，C，D，E的坐标，坐标为整数。

输出描述：

从出发到返回蜂巢最短路径的长度取整值，取整办法为放弃小数点后面的值。

示例：

输入：200 0 200 10 200 50 200 30 200 25

输出：456

说明：

样例中的10个数，相邻两个为一组，表示一个花丛的相对蜂巢的坐标：A(x1,y1),B(x2,y2),C(x3,y3),

D(x4,y4),E(x5,y5).分别代表x1,y1,x2,y2,x3,y3,x4,y4,x5,y5.

此题同：【回溯-全排列&&dfs】OD100. 基站维修工程师一样，由于问题规模也很小，只有5片花丛，所以使用全排列穷举所有路径是最优解决方案

      public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            // 注意 hasNext 和 hasNextLine 的区别
            int[] idx=new int[5];
            for(int i=0;i<points.length;i++){
                points[i][0]=in.nextInt();
                points[i][1]=in.nextInt();
                idx[i]=i;
            }

            permute(idx,0);
            System.out.println(ans);
        }

        private static void permute(int[] nums,int start){
            if(start==nums.length){
                long distance=computeDistance(nums);
                if(ans==null|| ans>distance){
                    ans=distance;
                }
                return;

            }

            for(int i=start;i<nums.length;i++){
                swap(nums,start,i);
                permute(nums,start+1);
                swap(nums,start,i);
            }
        }

        private static void swap(int[] nums,int i,int j){
            int tmp=nums[i];
            nums[i]=nums[j];
            nums[j]=tmp;
        }

        private static long computeDistance(int[] idx){

            double distance=0d;

            distance+=compute(0,0,points[idx[0]][0],points[idx[0]][1]);
            for(int i=0;i<points.length-1;i++){
                distance+=compute(points[idx[i]][0],points[idx[i]][1],
                        points[idx[i+1]][0],points[idx[i+1]][1]);
            }
            distance+=compute(0,0,points[idx[4]][0],points[idx[4]][1]); //注意这一行

            return (long)distance;

        }

        private static double compute(int x1,int y1,int x2,int y2){
            return Math.sqrt(1l*(x1-x2)*(x1-x2)+1l*(y1-y2)*(y1-y2));
        }