非递减子序列
题目描述
给你一个整数数组 nums
,找出并返回所有该数组中不同的递增子序列,递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。
数组中可能含有重复元素,如出现两个整数相等,也可以视作递增序列的一种特殊情况。
示例 1:
输入:nums = [4,6,7,7]
输出:[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2:
输入:nums = [4,4,3,2,1]
输出:[[4,4]]
解题思路
1. 回溯函数的参数和返回值
-
参数:
vector<int> &nums
:输入的数组,用于生成子序列。int startIndex
:当前处理的元素起始索引,用于控制遍历的起始位置。
-
返回值:无返回值(
void
),结果直接存储在类的成员变量result
中。
2. 回溯函数的终止条件
- 回溯函数没有显式的终止条件,因为它是通过循环和递归来遍历所有可能的子序列组合。循环会在
i
达到nums.size()
时自然结束。
3. 回溯函数的单层逻辑
- 剪枝逻辑:在循环中,通过检查当前元素是否小于
path
的最后一个元素,或者当前元素是否已经在当前层使用过,来避免生成不符合条件的子序列。 - 选择当前元素:将
nums[i]
添加到path
中,并记录当前元素已使用。 - 递归处理下一个元素:调用
backtracking(nums, i + 1)
,从下一个元素开始继续生成子序列。 - 回溯:在递归返回后,执行
path.pop_back()
,移除当前元素,以便尝试其他可能的选择。
代码实现
测试地址:https://leetcode.cn/problems/non-decreasing-subsequences/
class Solution {
private:
vector<int> path; // 当前正在处理的子序列路径
vector<vector<int>> result; // 存储所有非递减子序列的结果集
void backtracking(vector<int> &nums, int startIndex) {
// 如果当前子序列长度大于1,则将其添加到结果集中
if (path.size() > 1) {
result.push_back(path);
}
unordered_set<int> vset; // 用于记录当前层已经使用过的元素,避免重复
for (int i = startIndex; i < nums.size(); i++) {
// 剪枝逻辑:如果当前元素小于path的最后一个元素,或者当前元素已经在当前层使用过,则跳过
if (!path.empty() && nums[i] < path.back() || vset.find(nums[i]) != vset.end()) {
continue;
}
vset.insert(nums[i]); // 记录当前元素已使用
path.push_back(nums[i]); // 选择当前元素
backtracking(nums, i + 1); // 递归处理下一个元素
path.pop_back(); // 回溯:移除当前元素,尝试其他选择
}
}
public:
vector<vector<int>> findSubsequences(vector<int> &nums) {
backtracking(nums, 0); // 从索引 0 开始回溯
return result;
}
};
全排列
题目描述
给定一个不含重复数字的数组 nums
,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1:
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2:
输入:nums = [0,1]
输出:[[0,1],[1,0]]
示例 3:
输入:nums = [1]
输出:[[1]]
解题思路
1. 回溯函数的参数和返回值
-
参数:
vector<int> &nums
:输入的数组,用于生成排列。vector<bool> &used
:标记数组中每个元素是否已使用的布尔数组。
-
返回值:无返回值(
void
),结果直接存储在类的成员变量result
中。
2. 回溯函数的终止条件
- 当
path
的长度等于nums
的长度时,表示已经生成了一个完整的排列,此时将path
添加到result
中,并返回。
3. 回溯函数的单层逻辑
- 剪枝逻辑:在循环中,通过检查
used[i]
是否为true
来判断当前元素是否已经被使用过,如果是,则跳过该元素。 - 选择当前元素:将
nums[i]
添加到path
中,并标记used[i]
为true
。 - 递归处理下一个元素:调用
backtracking(nums, used)
,继续生成排列。 - 回溯:在递归返回后,执行
path.pop_back()
和used[i] = false
,移除当前元素并标记为未使用,以便尝试其他可能的选择。
代码实现
测试地址:https://leetcode.cn/problems/permutations/
class Solution {
private:
vector<int> path; // 当前正在处理的排列路径
vector<vector<int>> result; // 存储所有排列的结果集
void backtracking(vector<int> &nums, vector<bool> &used) {
// 如果当前排列的长度等于输入数组的长度,则将其添加到结果集中
if (path.size() == nums.size()) {
result.push_back(path);
return;
}
for (int i = 0; i < nums.size(); i++) {
// 如果当前元素已经被使用过,则跳过
if(used[i] == true) continue;
used[i] = true; // 标记当前元素已使用
path.push_back(nums[i]); // 选择当前元素
backtracking(nums, used); // 递归处理下一个元素
path.pop_back(); // 回溯:移除当前元素,尝试其他选择
used[i] = false; // 回溯:标记当前元素未使用
}
}
public:
vector<vector<int>> permute(vector<int> &nums) {
vector<bool> used(nums.size(), false); // 标记数组中每个元素是否已使用
backtracking(nums, used); // 从索引 0 开始回溯
return result;
}
};
全排列 II
题目描述
给定一个可包含重复数字的序列 nums
,按任意顺序 返回所有不重复的全排列。
示例 1:
输入:nums = [1,1,2]
输出:
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2:
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
解题思路
1. 回溯函数的参数和返回值
-
参数:
vector<int> &nums
:输入的数组,用于生成排列。vector<bool> &used
:标记数组中每个元素是否已使用的布尔数组。
-
返回值:无返回值(
void
),结果直接存储在类的成员变量result
中。
2. 回溯函数的终止条件
- 当
path
的长度等于nums
的长度时,表示已经生成了一个完整的排列,此时将path
添加到result
中,并返回。
3. 回溯函数的单层逻辑
- 剪枝逻辑:在循环中,通过检查
i > 0 && nums[i] == nums[i-1] && used[i-1] == false
来避免生成重复的排列。这个条件确保在处理重复元素时,只有在前一个相同元素已经被使用过的情况下才会选择当前元素。 - 选择当前元素:将
nums[i]
添加到path
中,并标记used[i]
为true
。 - 递归处理下一个元素:调用
backtracking(nums, used)
,继续生成排列。 - 回溯:在递归返回后,执行
path.pop_back()
和used[i] = false
,移除当前元素并标记为未使用,以便尝试其他可能的选择。
代码实现
测试地址:https://leetcode.cn/problems/permutations-ii/
class Solution {
private:
vector<int> path; // 当前正在处理的排列路径
vector<vector<int>> result; // 存储所有唯一排列的结果集
void backtracking(vector<int> &nums, vector<bool> &used) {
// 如果当前排列的长度等于输入数组的长度,则将其添加到结果集中
if (path.size() == nums.size()) {
result.push_back(path);
return;
}
for (int i = 0; i < nums.size(); i++) {
// 剪枝逻辑:避免重复排列
if(i > 0 && nums[i] == nums[i-1] && used[i-1] == false) continue;
// 如果当前元素已经被使用过,则跳过
if(used[i] == true) continue;
used[i] = true; // 标记当前元素已使用
path.push_back(nums[i]); // 选择当前元素
backtracking(nums, used); // 递归处理下一个元素
path.pop_back(); // 回溯:移除当前元素,尝试其他选择
used[i] = false; // 回溯:标记当前元素未使用
}
}
public:
vector<vector<int>> permuteUnique(vector<int> &nums) {
vector<bool> used(nums.size(), false); // 标记数组中每个元素是否已使用
sort(nums.begin(), nums.end()); // 对数组进行排序,以便处理重复元素
backtracking(nums, used); // 从索引 0 开始回溯
return result;
}
};
N皇后
题目描述
按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将 n
个皇后放置在 n×n
的棋盘上,并且使皇后彼此之间不能相互攻击。
给你一个整数 n
,返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案,该方案中 'Q'
和 '.'
分别代表了皇后和空位。
示例 1:
输入:n = 4
输出:[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释:如上图所示,4 皇后问题存在两个不同的解法。
示例 2:
输入:n = 1
输出:[["Q"]]
解题思路
1. 回溯函数的参数和返回值
-
参数:
int n
:棋盘的大小。int row
:当前处理的行。vector<string> &chessboard
:当前棋盘布局。
-
返回值:无返回值(
void
),结果直接存储在类的成员变量result
中。
2. 回溯函数的终止条件
- 当
row
等于n
时,表示已经生成了一个有效的棋盘布局,此时将chessboard
添加到result
中,并返回。
3. 回溯函数的单层逻辑
- 剪枝逻辑:在循环中,通过调用
isValid
函数来检查当前位置是否可以放置皇后。如果当前位置无效,则跳过该位置。 - 选择当前位置:将
chessboard[row][col]
设置为'Q'
,表示放置皇后。 - 递归处理下一行:调用
backtracking(n, row + 1, chessboard)
,继续处理下一行。 - 回溯:在递归返回后,执行
chessboard[row][col] = '.'
,移除皇后,以便尝试其他可能的位置。
代码实现
测试地址:https://leetcode.cn/problems/n-queens/
class Solution {
private:
vector<vector<string>> result; // 存储所有有效棋盘布局的结果集
void backtracking(int n, int row, vector<string> &chessboard) {
// 如果当前行等于n,表示已经生成了一个有效的棋盘布局
if (row == n) {
result.push_back(chessboard);
return;
}
for (int col = 0; col < n; col++) {
// 检查当前位置是否可以放置皇后
if (isValid(row, col, chessboard, n)) {
chessboard[row][col] = 'Q'; // 放置皇后
backtracking(n, row + 1, chessboard); // 递归处理下一行
chessboard[row][col] = '.'; // 回溯:移除皇后,尝试其他位置
}
}
}
bool isValid(int row, int col, vector<string> &chessboard, int n) {
// 检查当前列是否有其他皇后
for (int i = 0; i < row; i++) {
if (chessboard[i][col] == 'Q') {
return false;
}
}
// 检查左上对角线是否有其他皇后
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
// 检查右上对角线是否有其他皇后
for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
return true;
}
public:
vector<vector<string>> solveNQueens(int n) {
vector<string> chessboard(n, string(n, '.')); // 初始化棋盘
backtracking(n, 0, chessboard); // 从第0行开始回溯
return result;
}
};
解数独
题目描述
编写一个程序,通过填充空格来解决数独问题。
数独的解法需** 遵循如下规则**:
- 数字
1-9
在每一行只能出现一次。 - 数字
1-9
在每一列只能出现一次。 - 数字
1-9
在每一个以粗实线分隔的3x3
宫内只能出现一次。(请参考示例图)
数独部分空格内已填入了数字,空白格用 '.'
表示。
示例 1:
输入:board = [["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"]]
输出:[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释:输入的数独如上图所示,唯一有效的解决方案如下所示:
解题思路
1. 回溯函数的参数和返回值
-
参数:
vector<vector<char>> &board
:数独棋盘,用于存储和修改数独的数字。
-
返回值:
bool
:表示是否找到了有效的数独解。如果找到解,返回true
;否则返回false
。
2. 回溯函数的终止条件
- 当所有空位都填满时,即没有空位(
.
)时,返回true
。 - 如果在某个空位尝试了所有可能的数字(1到9)且都无效,返回
false
。
3. 回溯函数的单层逻辑
- 遍历棋盘:通过双重循环遍历棋盘的每个位置。
- 找到空位:如果当前位置是空位(
.
),则尝试填充1到9。 - 检查有效性:调用
isValid
函数检查当前填充的数字是否有效。 - 递归调用:如果当前数字有效,填充该数字并递归调用
backtracking
函数。 - 回溯:如果递归调用返回
false
,表示当前填充的数字无效,需要回溯,重置当前位置为空位(.
)。 - 剪枝逻辑:如果所有数字都尝试过且无效,返回
false
,表示当前路径无法找到解。
代码实现
测试地址:https://leetcode.cn/problems/sudoku-solver/description/
class Solution {
private:
bool backtracking(vector<vector<char>> &board) {
for (int i = 0; i < board.size(); i++) {
for (int j = 0; j < board[0].size(); j++) {
if (board[i][j] == '.') { // 找到一个空位
for (char k = '1'; k <= '9'; k++) { // 尝试填充1到9
if (isValid(i, j, k, board)) { // 检查当前数字是否有效
board[i][j] = k; // 填充当前数字
if (backtracking(board)) // 递归调用
return true; // 如果找到解,返回true
board[i][j] = '.'; // 回溯,重置当前位置
}
}
return false; // 如果所有数字都尝试过且无效,返回false
}
}
}
return true; // 如果所有空位都填满了,返回true
}
bool isValid(int row, int col, char val, vector<vector<char>> &board) {
for (int i = 0; i < 9; i++) {
if (board[row][i] == val) { // 检查行是否有重复
return false;
}
}
for (int j = 0; j < 9; j++) {
if (board[j][col] == val) { // 检查列是否有重复
return false;
}
}
int startRow = (row / 3) * 3;
int startCol = (col / 3) * 3;
for (int i = startRow; i < startRow + 3; i++) { // 检查3x3方格是否有重复
for (int j = startCol; j < startCol + 3; j++) {
if (board[i][j] == val) {
return false;
}
}
}
return true;
}
public:
void solveSudoku(vector<vector<char>> &board) {
backtracking(board);
}
};