leetcode之N皇后2（C++）

参考链接

1. https://leetcode-cn.com/problems/n-queens-ii/
2. https://leetcode-cn.com/problems/n-queens-ii/solution/nhuang-hou-ii-by-leetcode-solution/

题目描述

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

给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。

解题思路

可以就在N皇后1的代码基础上改改输出就行了，当然效率是很低的。因为只是要得到次数，所以不用生成棋盘，只需要判断能不能放棋子就行。

可以用集合存储当前哪些列和哪些对角线已经有棋子了，节省判断时间。这里利用规律是，左上到右下的对角线满足行与列的差相等，左下到右上的对角线满足行与列的和相等。

代码

N皇后1修改输出

class Solution {
public:
    int res = 0;
    int totalNQueens(int n) {
        vector<string> board(n, string(n, '.'));
        backtrack(board, 0);
        return res;
    }

    void backtrack(vector<string> board, int row)
    {
        if (row == board.size())
        {
            res += 1;
            return;
        }
        for (int col = 0; col < board[row].size(); col ++)
        {
            if (!isValid(board, row, col))
            {
                continue;
            }
            board[row][col] = 'Q';
            backtrack(board, row + 1);
            board[row][col] = '.';
        }
    }
    bool isValid(vector<string> board, int row, int col)
    {
        for (int i = row - 1; i >= 0; i --)
        {
            if (board[i][col] == 'Q')
            {
                return false;
            }
        }

        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i --, j --)
        {
            if (board[i][j] == 'Q')
            {
                return false;
            }
        }

        for (int i = row - 1, j = col + 1; i >= 0 && j < board[row].size(); i --, j ++)
        {
            if (board[i][j] == 'Q')
            {
                return false;
            }
        }
        return true;
    }
};

N皇后2

class Solution {
public:
    int totalNQueens(int n) {
        unordered_set<int> columns, diagonals1, diagonals2;
        return backtrack(n, 0, columns, diagonals1, diagonals2);
    }

    int backtrack(int n, int row, unordered_set<int>& columns, unordered_set<int>& diagonals1, unordered_set<int>& diagonals2) {
        if (row == n) {
            return 1;
        } else {
            int count = 0;
            for (int i = 0; i < n; i++) {
                if (columns.find(i) != columns.end()) {
                    continue;
                }
                int diagonal1 = row - i;
                if (diagonals1.find(diagonal1) != diagonals1.end()) {
                    continue;
                }
                int diagonal2 = row + i;
                if (diagonals2.find(diagonal2) != diagonals2.end()) {
                    continue;
                }
                columns.insert(i);
                diagonals1.insert(diagonal1);
                diagonals2.insert(diagonal2);
                count += backtrack(n, row + 1, columns, diagonals1, diagonals2);
                columns.erase(i);
                diagonals1.erase(diagonal1);
                diagonals2.erase(diagonal2);
            }
            return count;
        }
    }
};