回溯：棋盘问题
作者：互联网
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.搜索过程
本题中棋盘的每一个位置都要放一个数字，并检查数字是否合法：一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性。
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);
}
};
标签：return,int,chessboard,问题,vector,回溯,棋盘,col,row 来源： https://blog.csdn.net/qq_44781747/article/details/115468909