N皇后问题

LeetCode51：N皇后

n皇后问题研究的是如何将n个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击

上图为8皇后问题的一种解法

给定一个整数n，返回所有不同的n皇后问题的解决方案

每一种解法包含一个明确的n皇后问题的棋子放置方案，该方案中Q和.分别代表了皇后和空位

示例：

输入: 4
输出: [
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]
解释: 4 皇后问题存在两个不同的解法

解析：

n皇后问题的本质就是：有一个n×n的棋盘，希望往里放n个棋子，每个棋子所在的行、列、对角线都不能有另一个棋子

n皇后问题可以采用回溯法来解决，依次将n个棋子放到第一行、第二行、第三行……第n行。在放置的过程中，不停地检查当前的方法是否满足要求。如果满足，则跳到下一行继续放置棋子；如果不满足，那就再换一种方法，继续尝试

1）、回溯法1

    public List<List<String>> solveNQueens(int n) {
        List<List<String>> result = new ArrayList<>();
        char[][] tmp = new char[n][n];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                tmp[i][j] = '.';
            }
        }
        helper(tmp, 0, result);
        return result;
    }

    private void helper(char[][] tmp, int row, List<List<String>> result) {
        if (row == tmp.length) {//N个棋子都放置好了
            result.add(construct(tmp));
            return;
        }
        for (int column = 0; column < tmp.length; ++column) {//每一行有N种放法
            if (validate(tmp, row, column)) {
                tmp[row][column] = 'Q';
                helper(tmp, row + 1, result);//考察下一行
                tmp[row][column] = '.';
            }
        }
    }

    private boolean validate(char[][] tmp, int row, int column) {//判断row行column列放置是否合适
        int leftup = column - 1, rightup = column + 1;
        for (int rowIndex = row - 1; rowIndex >= 0; --rowIndex) {//逐行往上考察每一行
            if (tmp[rowIndex][column] == 'Q') return false; //考察竖直方向
            if (leftup >= 0 && tmp[rowIndex][leftup] == 'Q') return false;//考察左上对角线
            if (rightup < tmp.length && tmp[rowIndex][rightup] == 'Q') return false;//考察右上对角线
            leftup--;
            rightup++;
        }
        return true;
    }

    private List<String> construct(char[][] tmp) {
        List<String> list = new LinkedList<>();
        for (int i = 0; i < tmp.length; ++i) {
            list.add(new String(tmp[i]));
        }
        return list;
    }

2）、回溯法2

对于所有的捺（左上角到右下角）有行号 - 列号 = 常数，对于所有的撇有行号 + 列号 = 常数

    boolean[] col = null;
    boolean[] pie = null;//撇 
    boolean[] na = null;//捺
    List<List<String>> result = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        col = new boolean[n];
        pie = new boolean[2 * n - 1];
        na = new boolean[2 * n - 1];
        char[][] board = new char[n][n];
        helper(board, 0, n);
        return result;
    }

    private void helper(char[][] board, int row, int n) {
        if (row == n) {//N个棋子都放置好了
            result.add(construct(board));
            return;
        }
        Arrays.fill(board[row], '.');
        for (int i = 0; i < n; i++) {//每一行有N种放法
            if (!col[i] && !pie[row + i] && !na[row - i + n - 1]) {
                board[row][i] = 'Q';
                col[i] = true;
                pie[row + i] = true;
                na[row - i + n - 1] = true;//row - i可能为负数,+(n - 1)来防止数组越界
                helper(board, row + 1, n);//考察下一行
                board[row][i] = '.';
                col[i] = false;
                pie[row + i] = false;
                na[row - i + n - 1] = false;
            }
        }
    }

    private List<String> construct(char[][] tmp) {
        List<String> list = new LinkedList<>();
        for (int i = 0; i < tmp.length; ++i) {
            list.add(new String(tmp[i]));
        }
        return list;
    }

LeetCode52：N皇后 II

给定一个整数n，返回n皇后不同的解决方案的数量

题解：

    private int size;
    private int count;

    public int totalNQueens(int n) {
        count = 0;
        size = n;
        dfs(0, 0, 0, 0);
        return count;
    }

    private void dfs(int row, int col, int pie, int na) {
        //terminator(递归终止条件)
        if (row == size) {
            count++;
            return;
        }
        //process current logic(处理当前层逻辑)
        int bits = (~(col | pie | na)) & ((1 << size) - 1);//(1)
        while (bits != 0) {
            int p = bits & (-bits);//(2)
            //drill down(下探到下一层)
            dfs(row + 1, col | p, (pie | p) << 1, (na | p) >> 1);//(3)
            bits &= bits - 1;//(4)
        }
    }

1）、dfs方法中的参数：

row：代表当前递归计算的行数

col：表示递归计算到上一行为止，在哪些列上已经放置了皇后，1代表已经放置，0代表没有放置

pie：表示递归计算到上一行为止，受到皇后的左下方斜线的影响，导致当前行不能放置皇后，1代表不能放置，0代表可以放置。举个例子，第0行的皇后的左下方斜线影响的是第1行第3列。当计算到第2行时，第0行皇后的左下方斜线影响的是第2行第2列。当计算到第3行时，影响的是第3行第1列。当计算到第4行时，影响的是第4行第0列……pie每次左移一位，就可以得到之前所有皇后的左下方斜线对当前行的影响。同理na每次右移一位

2）、代码详解：

代码(1)处：col | pie | na得到col、pie、na都没有被占用的位置，这时候最后size位的0就代表可以放皇后的位置，通过~取反，把1变0，0变1，再通过& ((1 << size) - 1)将高位的1都去掉，只保留最后的size个位，最终计算得到的bits中所有的1代表可以放皇后的位置，接下来只需要在循环中枚举所有为1的位置

代码(2)处：得到最低位的1，这个位置就是当前要放皇后的位置

代码(3)处：递归，更新col、pie、na，p为当前层放皇后的位置，col | p占用掉col中当前层放皇后的位置，将col中一个为0的位更新为1，pie左移一位，na右移一位

代码(4)处：清零最低位的1

N皇后的位运算解法可能理解起来相对困难，我是通过学习极客时间的《算法面试通关40讲》中第42节《N皇后问题的另一种解法》才学会了这种解法的，向你推荐一下