回溯法的应用之N皇后问题

题目来源： leetcode 52

1、无优化版本 参考资料
Queen函数递归的放置第n个皇后，如果n>N 说明已经放完了，如果n小于N那么就准备放第n个，他可能放的位置有n*n个，依次找出所有可以放的位置，找到后做标记，然后放第n+1个皇后，在后续放完回来后，我们需要回溯！所以这个地方就不放第n个皇后了，所以要把标记擦除。
与此同时，这样的暴力算法会带来很多重复的情况，所以最后要在所有情况中除以n的阶乘

class Solution {
    int sum = 0, N = 0;
    int[][] board = null;

    boolean isFeasible(int m, int n) {

        //出界
        if (m < 0 || m >= N || n < 0 || n >= N)
            return false;

        //该位置已经有皇后
        if (1 == board[m][n])
            return false;

        //同行或同列有皇后
        for (int i = 0; i < N; i++) {
            if (1 == board[m][i] || 1 == board[i][n])
                return false;
        }

        //对角线有皇后
        for (int i = 1; i < N; i++) {
            //左上
            if (m - i >= 0 && n - i >= 0) {
                if (1 == board[m - i][n - i])
                    return false;
            }
            //左下
            if (m + i < N && n - i >= 0) {
                if (1 == board[m + i][n - i])
                    return false;
            }
            //右上
            if (m - i >= 0 && n + i < N) {
                if (1 == board[m - i][n + i])
                    return false;
            }
            //右下
            if (m + i < N && n + i < N) {
                if (1 == board[m + i][n + i])
                    return false;
            }
        }
        return true;
    }

    void Queue(int n) {
        if (n > N) {
            sum++;
        } else {
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (isFeasible(i, j)) {
                        board[i][j] = 1;
                        Queue(n + 1);
                        board[i][j] = 0;
                    }
                }
            }
        }
    }

    int factorial(int n){
        int mul = 1 ;
        for (int i = 1; i <= n ; i++)
            mul *= i;

        return mul;
    }

    public int totalNQueens(int n) {

        board = new int[n][n];
        N = n;

        Queue(1);
        return sum/factorial(N);
    }
}

暴力的结果就是太慢了！原因是放置皇后的时候有很多地方没必要判断，直接一人占据一行，其次是判断这个位置可不可以放也有点慢，可以改进为O(1)

2、改进算法

在这种情况下甚至都不需要board数组，就算需要用的话也不用二维数组，因为行已经确定了，所以不用位置矩阵，用一个一维数组，索引代表行，数字代表列即可！同时也消除了重复的情况

参考资料

class Solution {
   int sum = 0, N = 0;
    HashSet<Integer> diagonalLeft = new HashSet(), diagonalRight = new HashSet(), columns = new HashSet();

    boolean isFeasible(int row, int col) {

        if (columns.contains(col))
            return false;
        int sum = col + row, div = col - row;
        if (diagonalLeft.contains(sum) || diagonalRight.contains(div))
            return false;

        columns.add(col);
        diagonalLeft.add(sum);
        diagonalRight.add(div);

        return true;
    }

    //n是几就放到第n-1行
    void Queen(int n) {
        if (n > N) {
            sum++;
        } else {
            for (int i = 0; i < N; i++) {
                if (isFeasible(n - 1, i)) {
                    Queen(n + 1);
                    columns.remove(i);
                    diagonalLeft.remove(n - 1 + i);
                    diagonalRight.remove(i - n + 1);
                }
            }
        }
    }

    public int totalNQueens(int n) {

        N = n;

        Queen(1);
        return sum;
    }
}