骑士走棋盘问题

骑士走棋盘问题 国际象棋中骑士从棋盘任意位置出发一直将棋盘的每一个位置走一遍

这是国际象棋中骑士的可能走法，黑色表示骑士所在位置，红色表示骑士下一步能走的位置

骑士走棋盘问题 中 先走最难得位置（下一步可能性最少的位置），然后走容易的位置这样比较容易遍历整个棋盘

public class KnightAndBoard {
    public static class Step {
        int x, y; // 横坐标 纵坐标

        public Step(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    /**
     * 骑士遍历棋盘
     * 
     * @param start
     *            骑士第一步所在的坐标
     * @return
     */
    public static int[][] travelBoard(Step start) {
        int[][] board = new int[8][8]; // 初始化为0

        board[start.x][start.y] = 1;
        Step currentStep = start;

        for (int i = 2; i < 65; i++) {
            List<Step> possibleSteps = possibleSteps(currentStep, board);
            // 如果该坐标所有下一步都不能走
            if (possibleSteps.size() == 0)
                break;
            // 如果该坐标下一步只有一种可能性
            else if (possibleSteps.size() == 1) {
                currentStep = possibleSteps.get(0);
            }
            // 如果该坐标的下一步有多种可能性，那么就找出最复杂的一种可能性
            else {
                currentStep = hardStep(possibleSteps, board);
            }
            board[currentStep.x][currentStep.y] = i;
        }

        return board;

    }

    /**
     * 检查当前坐标所能到达的所有的下一步坐标，并返回下一步坐标list
     * 
     * @param step
     * @return
     */
    public static List<Step> possibleSteps(Step currentStep, int[][] board) {
        // 所有下一步方向集合
        int[][] dirs = { { -2, -1 }, { -1, -2 }, { 1, -2 }, { 2, -1 },
                { 2, 1 }, { 1, 2 }, { -1, 2 }, { -2, 1 } };
        List<Step> possibleList = new ArrayList<Step>();
        for (int[] dir : dirs) {
            Step nextStep = new Step(currentStep.x + dir[0], currentStep.y
                    + dir[1]);
            if (checkNext(board, nextStep))
                possibleList.add(nextStep);
        }
        return possibleList;
    }

    /**
     * 检查下一个坐标是否可走
     * 
     * @param board
     * @param nextDir
     * @return
     */
    public static boolean checkNext(int[][] board, Step nextStep) {
        return nextStep.x > -1 && nextStep.x < 8 && nextStep.y > -1
                && nextStep.y < 8 && board[nextStep.x][nextStep.y] == 0;
    }

    /**
     * 先走最难走的一步，也就是先走下一步可能性最少的一步
     * 
     * @param steps
     * @param board
     * @return
     */
    public static Step hardStep(List<Step> steps, int[][] board) {

        int minIndex = 0;
        List<Step> minStep = possibleSteps(steps.get(0), board);

        for (int i = 1; i < steps.size(); i++) {
            List<Step> nextSteps = possibleSteps(steps.get(i), board);
            if (nextSteps.size() < minStep.size()) {
                minIndex = i;
                minStep = nextSteps;
            }
        }
        return steps.get(minIndex);
    }

    public static void main(String args[]){
        
        KnightAndBoard knightAndBoard = new KnightAndBoard();
        Step start = new KnightAndBoard.Step(5, 6);
        for(int [] row :knightAndBoard.travelBoard(start)){
            for(int step : row)
                System.out.print(step + "\t");
            System.out.println();
        }
    }
}