八皇后（Java实现）

八皇后问题描述

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。

大体步骤

1.创建一个棋盘类
- 提供一些行 列属性
- 提供一个打印方法
- 提供一些清空方法
- 提供一个判断是否可以放置皇后的方法

2.每一行放置一个“皇后”， 放置成功后就去下一行放置
- 当所有行都放置成功了 那么就打印整个棋盘
- 如果需要放置皇后的那一行，没法在任何一个位置上放置“皇后” 则说明上一行所放置的皇后位置存在问题 上一行的皇后需要重新放置

具体实现

定义一个棋盘类

创建一个棋盘类

• 并提供行数、列数属性
• 使用int类型的二维数组来装载棋盘（可以放置皇后的位置标志为1否则标志为0）
• 重写toString方法

class Chess {

    private int rowSize = 8;
    private int colSize = 8;
    private int[][] chess;

    public int getRowSize() {
        return rowSize;
    }

    public int getColSize() {
        return colSize;
    }

    public int[][] getChess() {
        return chess;
    }

    public Chess() {
        this.chess = new int[rowSize][colSize];
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < rowSize; i++) {
            for (int j = 0; j < colSize; j++) {
                sb.append(chess[i][j]).append(" ");
            }
            sb.append("\n");
        }
        return sb.toString();
    }

}

chess类提供两个清空方法

• 重置所有数字的值
• 重置从某个行开始到最后一行所有行的数字的值

    /**
     * 将rowIndex开始的以下的所有的行都清空
     * 
     * @param rowIndex
     */
    public void clearBelowRow(int rowIndex) {

        for (int i = rowIndex; i < rowSize; i++) {
            for (int j = 0; j < colSize; j++) {
                chess[i][j] = 0;
            }
        }

    }

    /**
     * 重新初始化棋盘 将所有棋子清空
     */
    public void clear() {

        for (int i = 0; i < rowSize; i++) {
            for (int j = 0; j < colSize; j++) {
                chess[i][j] = 0;
            }
        }
    }

提供一个判断是否可以放置“皇后”的方法

• 要求1：所放置的行上不能存在“皇后”
• 要求2：所放置的列上不能存在“皇后”
• 要求3：所放置位置的两条对角线不能存在”皇后”

/**
     * 判断第i行 第j列 是否可以被放置
     * 
     * @param i
     *            行的index
     * @param j
     *            列的index
     * @return 是否可以被放置
     */
    public boolean canBePut(int rowIndex, int colIndex) {
        // 0.如果该位置已经被放置过了
        if (chess[rowIndex][colIndex] == 1)
            return false;
        // 1.判断第rowIndex行的每个元素是否有被放置过的
        for (int i = 0; i < colSize; i++) {
            if (chess[rowIndex][i] == 1) {
                return false;
            }
        }

        // 2. 判断第colIndex列的每个元素是否有被放置过的
        for (int i = 0; i < rowSize; i++) {
            if (chess[i][colIndex] == 1) {
                return false;
            }
        }

        // 3.判断对角线是否有被放置过的
        int i1 = rowIndex, j1 = colIndex;

        // 3.1.1 往左上方 
        while (i1 > 0 && j1 > 0) {
            i1--;
            j1--;
            if (chess[i1][j1] == 1) {
                return false;
            }
        }

        //3.1.2 右下方
        i1 = rowIndex;
        j1 = colIndex;
        while (i1 < rowSize - 1 && j1 < colSize - 1) {
            i1++;
            j1++;
            if (chess[i1][j1] == 1) {
                return false;
            }
        }

        // 3.2.1 往右上方  
        i1 = rowIndex;
        j1 = colIndex;
        while (i1 > 0 && j1 < colSize - 1) {
            i1--;
            j1++;
            if (chess[i1][j1] == 1) {
                return false;
            }
        }
        //3.2.2 左下方
        i1 = rowIndex;
        j1 = colIndex;
        while (i1 < rowSize - 1 && j1 > 0) {
            i1++;
            j1--;
            if (chess[i1][j1] == 1) {
                return false;
            }
        }

        return true;
    }

提供一个摆放“皇后”的方法

• 就是将某个位置的值置为 1

/**
     * 落子 将皇后放置在rowIndex行colIndex列上
     * 
     * @param rowIndex
     *            行
     * @param colIndex
     *            列
     */
    public void downPiece(int rowIndex, int colIndex) {
        this.chess[rowIndex][colIndex] = 1;
    }

使用递归摆放每一行

• 提供一个递归方法：
  – 终止条件：已经放置过了最后一行，打印当前的棋盘
  – 递归位置：在rowIndex行成功放置皇后之后
• 注意：在放置之前现将当前放置的行以及其下面的所有行“清空”一下

    /**
     * 找寻当前行可以放置皇后的点
     * 
     * @param rowIndex
     *            哪一行
     * @param chess
     *            棋盘
     */
    public static void putInRow(int rowIndex, Chess chess) {
        // 已经到了最后一行了
        if (rowIndex >= chess.getRowSize()) {
            System.out.println("棋盘" + count++);
            System.out.println(chess);
        } else {

            int[] currentRow = chess.getChess()[rowIndex];

            for (int colIndex = 0; colIndex < currentRow.length; colIndex++) {

                // 先将这一行 以及其下面的所有行 全都置为0
                chess.clearBelowRow(rowIndex);

                if (chess.canBePut(rowIndex, colIndex)) {
                    // 如果这一行可以放置，那么进入下一行进行放置
                    chess.downPiece(rowIndex, colIndex);
                    putInRow(rowIndex + 1, chess);
                }
            }

            // 如果执行到这里,表示当前行无法放置“皇后”
            // 也就说明上一行放置了“皇后”的位置这时会导致下面的行无法再进行放置
            // 因此上一行“皇后”的位置需要被重新放置

        }
    }

Main方法调用

public static void main(String[] args) {
        Chess chess = new Chess();
        putInRow(0, chess);
    }

输出效果