回溯：棋盘问题

最新推荐文章于 2022-12-14 14:20:47 发布

上帝爱民

最新推荐文章于 2022-12-14 14:20:47 发布

阅读量196

点赞数

分类专栏：算法题

本文链接：https://blog.csdn.net/qq_44781747/article/details/115468909

版权

算法题专栏收录该内容

30 篇文章 1 订阅

订阅专栏

LeetCode51. N皇后

https://leetcode-cn.com/problems/n-queens/

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

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

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

在这里插入图片描述

输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。

思路

回溯模板：

void backtracking(选择列表，路径，结果) 
{
    if (终止条件) 
    {
        存放结果;
        return;
    }

    for (在选择列表中选择) 
    {
        处理节点;
        backtracking(选择列表，路径，结果); 
        回溯，撤销处理结果
    }
}

所有用回溯解决的问题都可以抽象为树形结构：

回溯三部曲：

1.递归函数的返回值和参数

定义全局变量二维数组result来存放所有符合条件的棋盘的结果集合。

参数n是棋盘的大小，参数row来记录当前遍历到棋盘的第几层。

    //存放所有符合条件的棋盘的结果集合
    vector<vector<string>> result;

    void backtrack(vector<string>& chessboard, int n, int row)

2.递归函数的终止条件

当递归到棋盘最底层(也就是叶子节点)的时候，就可以收集符合条件的棋盘并返回了。

        if (row == n)
        {
            result.push_back(chessboard);
            return;
        }

3.搜索过程

递归深度即row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。

每一层都是要从新的一行的起始位置开始搜，所以每一层里for循环的col都是从0开始。

验证放置位置是否合法：

不能同行
不能同列
不能同斜线（135度角和45度角）

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

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

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

        return true;
    }

代码

class Solution 
{
private:
    bool isValid(vector<string>& chessboard, int n, int row, int col)
    {
        //列
        for (int i = 0; i < row; i++)
        {
            if (chessboard[i][col] == 'Q')
            {
                return false;
            }
        }

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

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

        return true;
    }
    
    //存放所有符合条件的棋盘的结果集合
    vector<vector<string>> result;

    void backtrack(vector<string>& chessboard, int n, int row)
    {
        if (row == n)
        {
            result.push_back(chessboard);
            return;
        }
        
        //控制树的横向遍历
        for (int col = 0; col < n; ++col)
        {
            if (isValid(chessboard, n, row, col))
            {
                chessboard[row][col] = 'Q';  //放置皇后

                backtrack(chessboard, n, row + 1);  //递归：控制树的纵向遍历

                chessboard[row][col] = '.';  //回溯，撤销皇后
            }
        }
    }

public:
    vector<vector<string>> solveNQueens(int n) 
    {
        vector<string> chessboard(n, string(n, '.'));
        backtrack(chessboard, n, 0);

        return result;
    }
};

LeetCode52. N皇后II

https://leetcode-cn.com/problems/n-queens-ii/

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

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

输入：n = 4
输出：2
解释：如上图所示，4 皇后问题存在两个不同的解法。

思路

本题与LeetCode51. N皇后基本相同，唯一的区别是：

LeetCode51. N皇后求的是所有不同的 n 皇后问题的解决方案；而本题求的是n 皇后问题不同的解决方案的数量。

代码

class Solution 
{
private:
    bool isValid(vector<string>& chessboard, int n, int row, int col)
    {
        //列
        for (int i = 0; i < row; i++)
        {
            if (chessboard[i][col] == 'Q')
            {
                return false;
            }
        }

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

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

        return true;
    }

    int count = 0;

    void backtrack(vector<string>& chessboard, int n, int row)
    {
        if (row == n)
        {
            ++count;
            return;
        }
        
        //控制树的横向遍历
        for (int col = 0; col < n; ++col)
        {
            if (isValid(chessboard, n, row, col))
            {
                chessboard[row][col] = 'Q';  //放置皇后

                backtrack(chessboard, n, row + 1);  //递归：控制树的纵向遍历

                chessboard[row][col] = '.';  //回溯，撤销皇后
            }
        }
    }

public:
    int totalNQueens(int n) 
    {
        vector<string> chessboard(n, string(n, '.'));
        
        backtrack(chessboard, n, 0);

        return count;
    }
};

LeetCode36. 有效的数独

https://leetcode-cn.com/problems/valid-sudoku/

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

上图是一个部分填充的有效的数独。

数独部分空格内已填入了数字，空白格用 '.' 表示。

输入:
[
  ["5","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
输出: true

思路

使用数组作为哈希表，保存每个单元格值是否已经在当前的行 / 列 / 子数独中出现过：如果未出现过，数组对应的值为1；如果已出现过，数组对应的值为0 。具体步骤：

遍历数独。
检查看到每个单元格值是否已经在当前的行 / 列 / 子数独中出现过：
- 如果出现重复，返回 false。
- 如果没有，则保留此值(将数组对应的值置为1)以进行进一步跟踪。

子数独表示方式：

可以使用 boxes_index = (row / 3) * 3 + col / 3。

代码

class Solution 
{
public:
    bool isValidSudoku(vector<vector<char>>& board) 
    {
        vector<vector<int>> rows(9, vector<int>(9, 0));
        vector<vector<int>> cols(9, vector<int>(9, 0));
        vector<vector<int>> boxes(9, vector<int>(9, 0));
    
        for (int row = 0; row < 9; ++row)
        {
            for (int col = 0; col < 9; ++col)
            {
                if (board[row][col] == '.') continue;

                int num = board[row][col] - '1';
                if (rows[row][num] == 1) return false;
                if (cols[col][num] == 1) return false;
                if (boxes[(row / 3) * 3 + col / 3][num] == 1) return false; 

                rows[row][num] = 1;
                cols[col][num] = 1;
                boxes[(row / 3) * 3 + col / 3][num] = 1;
            }
        }

        return true;
    }
};

LeetCode37. 解数独

https://leetcode-cn.com/problems/sudoku-solver/

编写一个程序，通过填充空格来解决数独问题。

一个数独的解法需遵循如下规则：

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

空白格用 '.' 表示。

在这里插入图片描述

一个数独。

在这里插入图片描述

答案被标成红色。

提示：

给定的数独序列只包含数字 1-9 和字符 '.' 。
你可以假设给定的数独只有唯一解。
给定数独永远是 9x9 形式的。

思路

棋盘搜索问题可以使用回溯暴力搜索，需要使用二维递归。

怎么做二维递归呢？

本题中棋盘的每一个位置都要放一个数字，并检查数字是否合法：一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性。

所有用回溯解决的问题都可以抽象为树形结构：

回溯三部曲：

1.递归函数的返回值和参数

递归函数的返回值需要是bool类型

解数独找到一个符合的条件(树的叶子节点上)立刻就返回，相当于找到了从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。

    bool backtrack(vector<vector<char>>& board)

2.递归函数的终止条件

本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。

3.搜索过程

    bool backtrack(vector<vector<char>>& board)
    {
        //遍历行
        for (int row = 0;row < 9;++row)
        {
            //遍历列
            for (int col = 0;col < 9;++col)
            {
                if (board[row][col] != '.') continue;

                for (char val = '1'; val <= '9'; ++val)
                {
                    //(i, j) 这个位置放k是否合适
                    if (isValid(row, col, val, board))
                    {
                        board[row][col] = val;  //放置k
                        if (backtrack(board)) return true;  //如果找到合适棋盘位置立刻返回
                        board[row][col] = '.';  //回溯，撤销k
                    }
                }
                return false;  //对棋盘的某个位置9个数都试完了，都不行，那么就返回false
            }
        }

        return true;  //棋盘遍历完没有返回false，说明找到了合适棋盘位置
    }

注意这里return false的地方。

如果一行一列确定下来了，在这个位置尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解，那么会直接返回false。

判断棋盘是否合法：

判断棋盘是否合法有如下三个维度：

同行是否重复
同列是否重复
子数独里是否重复

    bool isValid(int row, int col, char val, const vector<vector<char>>& board)
    {
        //判断行里是否重复
        for (int i = 0; i < 9; ++i)
        {
            if (board[i][col] == val)
            {
                return false;
            }
        }

        //判断列里是否重复
        for (int j = 0; j < 9; ++j)
        {
            if (board[row][j] == val)
            {
                return false;
            }
        }

        //判断子数独里是否重复
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; ++i)
        {
            for (int j = startCol; j < startCol + 3; ++j)
            {
                if (board[i][j] == val)
                {
                    return false;
                }
            }
        }

        return true; 
    }

代码

class Solution 
{
private:
    bool isValid(int row, int col, char val, const vector<vector<char>>& board)
    {
        //判断行里是否重复
        for (int i = 0; i < 9; ++i)
        {
            if (board[i][col] == val)
            {
                return false;
            }
        }

        //判断列里是否重复
        for (int j = 0; j < 9; ++j)
        {
            if (board[row][j] == val)
            {
                return false;
            }
        }

        //判断子数独里是否重复
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; ++i)
        {
            for (int j = startCol; j < startCol + 3; ++j)
            {
                if (board[i][j] == val)
                {
                    return false;
                }
            }
        }

        return true; 
    }

    bool backtrack(vector<vector<char>>& board)
    {
        //遍历行
        for (int row = 0;row < 9;++row)
        {
            //遍历列
            for (int col = 0;col < 9;++col)
            {
                if (board[row][col] != '.') continue;

                for (char val = '1'; val <= '9'; ++val)
                {
                    //(i, j) 这个位置放k是否合适
                    if (isValid(row, col, val, board))
                    {
                        board[row][col] = val;  //放置k
                        if (backtrack(board)) return true;  //如果找到合适棋盘立刻返回
                        board[row][col] = '.';  //回溯，撤销k
                    }
                }
                return false;  //对棋盘的某个位置9个数都试完了，都不行，那么就返回false
            }
        }

        return true;  //棋盘遍历完没有返回false，说明找到了合适棋盘
    }
    
public:
    void solveSudoku(vector<vector<char>>& board) 
    {
        backtrack(board);
    }
};

上帝爱民

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
回溯：棋盘问题

LeetCode51. N皇后https://leetcode-cn.com/problems/n-queens/n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数 n ，返回所有不同的 n 皇后问题的解决方案。每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。输入：n = 4输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","
复制链接

扫一扫