回溯法——关于n皇后的一些例题

昨天写了一篇博客：回溯法——从八皇后问题讲起
现在来看一下几道Leetcode上面的例题：

[版权声明] 本文部分内容转载自：
1、回溯算法详解 作者：labuladong
2、「手画图解」从N皇后问题看回溯算法 作者：笨猪爆破组

一、解题思路

回溯算法有固定的框架框架。
解决一个回溯问题，实际上就是一个决策树的遍历过程。你只需要思考 3 个问题：
1、路径：也就是已经做出的选择。
2、选择列表：也就是你当前可以做的选择。
3、结束条件：也就是到达决策树底层，无法再做选择的条件。

再看两张4皇后的图：

（因为上一篇博客有讲，就不啰嗦了。不明白的话，可以点链接进去看说明。）

二、51. N 皇后

原题链接：https://leetcode-cn.com/problems/n-queens/
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

上图为 8 皇后问题的一种解法。
给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

解题思路：

函数 solute 依然像个在决策树上游走的指针，通过 row 和 col 就可以表示函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：

好，来看一下代码：

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        //vector<vector<string>>results包含很多个 vector<string>board
        //一个vector<string>board表示一种 nxn 的结果
        vector<vector<string>>results;
        vector<string>board(n, string(n, '.')); // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
        solute(results, board, 0);
        return results;
    }

    //路径：board 中小于 row 的那些行都已经成功放置了皇后
    // 选择列表：第 row 行的所有列都是放置皇后的选择
    // 结束条件：row 超过 board 的最后一行
    void solute(vector<vector<string>>&results, vector<string>&board, int currentRow)
    {
        if(currentRow == board.size())
        {
            results.push_back(board);
            return;
        }

        //board 中小于 row 的那些 "行" 都已经成功放置了皇后
        //注意for循环是判断 "列"
        int n= board[currentRow].size();
        for(int col=0; col<n; col++)
        {
            // 排除不合法选择
            if(isValid(board, currentRow, col))
            {
                board[currentRow][col]='Q';
                solute(results, board, currentRow+1);
                board[currentRow][col]='.';
            }
        }
    }

    bool isValid(vector<string>&board, int row, int col)
    {
        int n=board.size();
        // 检查列是否有皇后互相冲突(通过每一**行**的第col列函数来检测)
        //因为该**列**是肯定没冲突，所以不需要检查**行**是否有冲突
        for(int i=0; i<n; i++)
        {
            if(board[i][col]=='Q') return false;
        }

        // 检查左上方是否有皇后互相冲突
        //for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--)
        for(int i=row,j=col; i>=0&&j>=0; i--,j--)
        {
            if(board[i][j]=='Q') return false;
        }

        // 检查右上方是否有皇后互相冲突
        //for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) 
        for(int i=row,j=col; i>=0&&j>=0; i--,j++)
        {
            if(board[i][j]=='Q') return false;
        }
        return true;
    }
};

三、52. N皇后 II

原题链接：https://leetcode-cn.com/problems/n-queens-ii/

题目内容和上面大致一样，区别在于**返回 n 皇后不同的解决方案的数量。

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

    void solute(vector<string>&board, int currentRow)
    {
        //因为循环是从 0 到 currentRow-1
        //所以到currentRow的时候，就已经说明找到一条路径了
        if(currentRow == board.size())
        {
            count++;
            return;
        }

        int n= board[currentRow].size();
        for(int col=0; col<n; col++)
        {
            if(isValid(board, currentRow, col))
            {
                board[currentRow][col]='Q';
                solute(board, currentRow+1);
                board[currentRow][col]='.';
            }
        }
    }

    bool isValid(vector<string>&board, int row, int col)
    {
        int n=board.size();
        for(int i=0; i<n; i++)
        {
            if(board[i][col]=='Q') return false;
        }

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

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

四、面试题 08.12. 八皇后

原题链接： https://leetcode-cn.com/problems/eight-queens-lcci/

（题目差不多的，我就不复制过来了，可以点进去链接来看）

解题思路也差不多的，那就直接贴代码吧：

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>>results;
        vector<string>one(n, string(n,'.'));
        queen(results, one, 0);
        return results;
    }

    void queen(vector<vector<string>>&results, vector<string>&one, int currentRow)
    {
        if(currentRow == one.size())
        {
            results.push_back(one);
            return;
        }

        for(int col=0; col<one.size(); col++)
        {
            if(isValid(one, currentRow,col)==true)
            {
                one[currentRow][col]='Q';
                queen(results, one, currentRow+1);
                one[currentRow][col]='.';
            }
        }
    }

    bool isValid(vector<string>&one, int row, int col)
    {
        for(int i=0; i<row; i++) //这里的判断条件，i<row 比 i<one.size() 好
        {
            if(one[i][col]=='Q') return false;
        }

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

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