java骑士周游问题

考虑国际象棋棋盘上某个位置的一只马，它是否可能只走63步，正好走过除起点外的其他63个位置各一次？如果有一种这样的走法，则称所走的这条路线为一条马的周游路线。试设计一个算法找出这样一条马的周游路线。 

在一个8×8的方格棋盘中，按照国际象棋中马的行走规则从棋盘上的某一方格出发，开始在棋盘上周游，如果能不重复地走遍棋盘上的每一个方格，

能够想到的思路是用回溯，马在每一个点最多有8种跳法，遍历所有这8种可能的跳法即可得到结果。这是回溯算法中的子集树的类型，与典型的子集树问题类型不同的是，这里每一枝有8种可能的选择，而典型的子集树问题只有0，1两种选择。
源码：

package com.hwk.reg;

import java.awt.*;
import java.util.ArrayList;
import java.util.Comparator;

public class horesChess_1 {
    private static int X = 8;//棋盘的大小
    private static int Y = 8;
    private static int[][] chessBorad = new int[Y][X];
    private static boolean[] visited = new boolean[Y * X];//标记是否走过
    private static boolean finish = false;

    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        //寻找走的方法
       traverchessBorad(chessBorad,3,3,1);
       Long end = System.currentTimeMillis();
       System.out.println(end-start);
       //遍历输出路径
        for (int[] rows : chessBorad) {
            for (int step : rows) {
                System.out.print(step + "\t");
            }
            System.out.println();
        }

    }
    //核心，递归和追溯
    public static void traverchessBorad(int [][] chessBorad,int row,int col,int step){
        //标记第几步
        chessBorad[row][col] = step;
        //标记已经走过
        visited[row*X+col] = true;
        //获得下一步可以走的路
        ArrayList<Point> points = next(new Point(col,row));
        //排序
        sort(points);
        //没有进入困局就遍历每一种走法
        while (!points.isEmpty()){
            //按顺序遍历每一种走法，用过即删
            Point p = points.remove(0);
            //判断这条路是否走过
            if(!visited[p.y*X+ p.x]){
                //递归，继续往下走
                traverchessBorad(chessBorad,p.y,p.x,step+1);
            }
        }
        //追随，如果这条路失败，重置刚才的行为，并且进入上一层递归，遍历下一个选择
        if(step < X*Y && !finish){
            chessBorad[row][col] = 0;
            visited[row*X+col] = false;
        }
        //成功就标记为true
        else{
            finish = true;
        }
    }
    // 将下一步可以走的所有路放到集合
    public static ArrayList<Point> next(Point point){
        ArrayList<Point> points = new ArrayList<>();
        Point point1 = new Point();
        //马走日
        if((point1.x = point.x -2) >= 0 && (point1.y = point.y -1) >= 0){
            points.add(new Point(point1));
        }
        if((point1.x = point.x -1) >= 0 && (point1.y = point.y -2) >= 0){
            points.add(new Point(point1));
        }
        if((point1.x = point.x +1) < X && (point1.y = point.y -2) >= 0 ){
            points.add(new Point(point1));
        }
        if((point1.x = point.x +2) < X && (point1.y = point.y -1) >= 0 ){
            points.add(new Point(point1));
        }
        if((point1.x = point.x -2) >= 0 && (point1.y = point.y +1) < Y ){
            points.add(new Point(point1));
        }
        if((point1.x = point.x +1 ) < X && (point1.y = point.y +2) < Y){
            points.add(new Point(point1));
        }
        if((point1.x = point.x -1 ) >= 0 && (point1.y = point.y + 2) < Y){
            points.add(new Point(point1));
        }
        if((point1.x = point.x +2 ) < X && (point1.y = point.y + 1) < Y){
            points.add(new Point(point1));
        }
        return  points;
    }
    //对可选择的路的集合进行升序排序，把路少的排在前面，这样可以少走一些路
    public static void sort(ArrayList<Point> ponits){
        ponits.sort(new Comparator<Point>() {
            @Override
            public int compare(Point o1, Point o2) {
                return next(o1).size()-next(o2).size();
            }
        });
    }
}