第七章 回溯算法 part04

最新推荐文章于 2024-08-18 08:31:43 发布
最新推荐文章于 2024-08-18 08:31:43 发布
阅读量255 收藏 4
点赞数 5
分类专栏： 代码随想录 文章标签： 算法 leetcode 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a781333978/article/details/140613745
版权

非递减子序列

题目描述

给你一个整数数组 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. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 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);
    }
};
C1aySec
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录 day28 第七章 回溯算法part04
weixin_60315213的博客
03-21 481
● 93.复原IP地址。● 90.子集II。
Day 27 第七章 回溯算法part04
wxw154170875的博客
10-05 76
3道题目。
代码随想录 第七章 回溯算法 part04 51.N皇后
qq_53524614的博客
08-13 202
说起来其实不难，只要能正确判断一个位置是否能放皇后就能解决，笔者一开始没看清输出要求，以为是棋盘是拉直后整个输出，所以用一维容器来表示棋盘，用二维容器表示棋盘时判断是否能放皇后会更加容易。由于N皇后的性质，棋盘一行必须有且仅有一个皇后，所以回溯可按行分层，省去了在在判断是否能放皇后时对行进行检查的步骤。
【随想录】Day28—第七章 回溯算法part04
weixin_44382896的博客
04-21 615
子集II 与 子集 的区别在于，数组中存在重复元素，涉及重复元素的去重逻辑。startIndex 作用在于，告诉下一层递归从哪里开始取数。获取子串 ——> 判断子串是否合法 ——> 收集结果。本题思路属于切割问题，
代码随想录 第七章 回溯算法 part04 332.重新安排行程
qq_53524614的博客
08-12 301
随想录的解法通过建立unordered_map，将从一个机场到其他机场的可能性都包含在unordered_map下的map，这样在回溯过程中不需要遍历tickets寻找合适的票，并且map基于黑红树实现，能够自动实现排序，因此通过map存储机场到其他机场的余票，遍历过程中天然就可以排除所有字典排序不是最小的路线，找到的第一条可行路线就是最小的。笔者也尝试将删除路线的部分用于在回溯过程中剪枝，但依然超时，所以去看了随想录的解法，然后照着随想录的思路写。
代码随想录 第七章 回溯算法 part04 37.解数独
qq_53524614的博客
08-16 195
这题笔者一开始设想的回溯函数需要的参数包括当前数独数组与要进行回溯的元素坐标，但是在编写过程中发现，这样写对于如何回溯与合适结束回溯需要比较复杂的判断，所以在这里还是使用了随想录所给的思路，即不传递下一格需要回溯的元素位置，而是由回溯函数自行寻找仍然没填上数字的位置，这样虽然会增加一定的时长，但是对于何时结束回溯的判断逻辑比较简明。
代码随想录算法训练营第25天 | 第七章 回溯算法part04
monoki的博客
07-03 141
Leetcode链接 46.全排列 Leetcode链接排列问题：[1,2] 和 [2,1]是两个集合——不需要index 但是纵向的排列问题需要一个vector used数组来标记是否使用过这个元素 47.全排列Ⅱ Leetcode链接
代码随想录算法训练营第28天 |第七章 回溯算法part04
qq_43750923的博客
02-22 896
用于跳过当前迭代，继续下一次迭代，而。用于立即退出当前循环。
刷题训练 day24 | 第七章 回溯算法 part04
m0_47869044的博客
11-09 39
【代码】刷题训练 day23 | 第七章 回溯算法 part04。
算法设计与分析习题解答(第2版） 光盘内容 part2.rar
06-30
《算法设计与分析习题解答（第2版）》是一本深入探讨算法设计与分析的教材，其光盘内容part2.rar可能包含了该书的补充资料、练习题解答、课后习题答案以及可能的编程实例等内容。这部分内容对于学习者来说极其重要，...
Algorithm-Part-1:算法第1部分中的课程设置解决方案
05-18
在“Algorithm-Part-1:算法第1部分中的课程设置解决方案”这个项目中，我们可以预见到一系列关于算法和数据结构的深入学习。作为标签指明了“Java”，我们可以推测这可能是使用Java语言来讲解和实现这些算法的。下面...
算法设计与分析课件part1
10-13
4. **第七章 回溯**: 回溯是一种试探性的解决问题方法，常用于解决组合优化问题，如八皇后问题、数独等。回溯算法通常包含深度优先搜索的策略，通过撤销先前的选择来尝试其他路径。 5. **第八章 分支与限界**: 分支...
coursera-algorithms-part-1
06-27
7. **贪心算法**：这种算法在每一步选择局部最优解，以期望全局最优。如活动选择问题和霍夫曼编码。 8. **回溯法**：用于在问题的解空间树中搜索解的算法，常用于解决组合优化问题，如八皇后问题、数独求解等。 在...
杭电ACM资料（part2）
10-31
第5章 回溯法.rar很可能包含了关于如何运用回溯法解决实际问题的实例和代码实现，例如八皇后问题、数独求解等。 2. **数据结构**：数据结构是计算机科学中的核心概念，它涉及如何有效地存储和组织数据，以便于高效...
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
业精于勤，荒于嬉
08-14 1237
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 825
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
LeeCode Practice Journal | Day43_DP10
Janniam的博客
08-14 283
上题的变体，与nums[i]前每一个连续的元素比较变为前一个元素比较。2、返回值不是dp[i]，是dp数组中的最大值。1、数组元素要初始化为1。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
最新发布
2302_78914800的博客
08-18 379
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值