第七章回溯算法part02

最新推荐文章于 2024-07-25 23:26:35 发布

C1aySec

最新推荐文章于 2024-07-25 23:26:35 发布

阅读量316

点赞数 5

分类专栏：代码随想录文章标签：算法数据结构 c++ leetcode

本文链接：https://blog.csdn.net/a781333978/article/details/140613667

版权

代码随想录专栏收录该内容

43 篇文章 0 订阅

订阅专栏

组合总和

题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

解题思路

递归流程说明：

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

参数：
- vector<int> &candidates：输入的候选数组。
- int targetSum：目标和。
- int sum：当前组合的和。
- int startIndex：当前处理的元素在数组中的索引。
返回值：无返回值，直接修改类成员 result 来保存所有可能的组合。

2. 递归函数的终止条件

当 sum > targetSum 时，说明当前和已经超过了目标和，直接返回。
当 sum == targetSum 时，说明当前和等于目标和，将当前组合 path 添加到结果集 result 中，并返回。

3. 递归函数的单层逻辑

循环遍历候选数组，从 startIndex 开始。
在循环中，更新当前和 sum 并添加当前元素到 path 中。
递归调用回溯函数处理下一个元素。
完成递归后，进行回溯，移除上一步添加的元素，以便尝试下一个元素。

回溯过程和剪枝逻辑

回溯过程：
- 在每次递归调用之后，通过 sum -= candidates[i] 和 path.pop_back() 撤销之前的选择（即移除了最后一个元素并更新了和），这样就可以在接下来的循环迭代中尝试其他可能的元素，从而枚举所有可能的组合。
剪枝逻辑：
- 在循环中，sum + candidates[i] <= targetSum 是一个剪枝条件，用于减少不必要的递归调用。这个条件确保了从当前元素开始到数组末尾的元素的和不会超过目标和。如果当前元素加上当前和已经超过了目标和，就没必要继续递归，因为即使递归下去也无法获得有效的组合。

代码实现

测试地址：https://leetcode.cn/problems/combination-sum/

class Solution {
private:
    vector<int> path; // 用于保存当前的组合
    vector<vector<int>> result; // 用于保存所有可能的组合

    // 回溯函数
    void backtracking(vector<int> &candidates, int targetSum, int sum, int startIndex) {
        // 剪枝：如果当前和大于目标和，直接返回
        if (sum > targetSum)
            return;
        // 终止条件：如果当前和等于目标和
        if (sum == targetSum) {
            result.push_back(path); // 将当前组合添加到结果集中
            return;
        }
        // 循环遍历候选数组
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= targetSum; i++) {
            sum += candidates[i]; // 更新当前和
            path.push_back(candidates[i]); // 将当前元素添加到组合中
            backtracking(candidates, targetSum, sum, i); // 递归调用，处理下一个元素
            sum -= candidates[i]; // 回溯，移除上一步添加的元素
            path.pop_back(); // 回溯，移除上一步添加的元素
        }
    }

public:
    // 主函数：生成目标和的组合
    vector<vector<int>> combinationSum(vector<int> &candidates, int target) {
        sort(candidates.begin(), candidates.end()); // 对候选数组进行排序
        backtracking(candidates, target, 0, 0); // 从第一个元素开始回溯
        return result;
    }
};

组合总和II

题目描述

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

注意： 解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

解题思路

递归流程说明：

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

参数：
- vector<int> &candidates：输入的候选数组。
- int target：目标和。
- int sum：当前组合的和。
- int startIndex：当前处理的元素在数组中的索引。
- vector<bool> &used：用于标记元素是否已使用的布尔数组。
返回值：无返回值，直接修改类成员 result 来保存所有可能的组合。

2. 递归函数的终止条件

当 sum == target 时，说明当前和等于目标和，将当前组合 path 添加到结果集 result 中，并返回。

3. 递归函数的单层逻辑

循环遍历候选数组，从 startIndex 开始。
在循环中，更新当前和 sum 并添加当前元素到 path 中。
使用 used 数组标记当前元素已使用，并递归调用 backtracking 处理下一个元素。
完成递归后，执行 used[i] = false、sum -= candidates[i] 和 path.pop_back() 进行回溯，移除上一步添加的元素，以便尝试下一个元素。

回溯过程和剪枝逻辑

回溯过程：
- 在每次递归调用之后，通过 used[i] = false、sum -= candidates[i] 和 path.pop_back() 撤销之前的选择（即移除了最后一个元素并更新了和），这样就可以在接下来的循环迭代中尝试其他可能的元素，从而枚举所有可能的组合。
剪枝逻辑：
- 在循环中，sum + candidates[i] <= target 是一个剪枝条件，用于减少不必要的递归调用。这个条件确保了从当前元素开始到数组末尾的元素的和不会超过目标和。
- 另一个剪枝条件是 if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false)，用于避免生成重复的组合。这个条件确保了在处理重复元素时，只有在前一个相同元素已经使用过的情况下才会继续处理当前元素，从而避免了重复的组合。

代码实现

测试地址：https://leetcode.cn/problems/combination-sum-ii/

class Solution {
private:
    vector<int> path; // 用于保存当前的组合
    vector<vector<int>> result; // 用于保存所有可能的组合

    // 回溯函数
    void backtracking(vector<int> &candidates, int target, int sum, int startIndex, vector<bool> &used) {
        // 终止条件：如果当前和等于目标和
        if (sum == target) {
            result.push_back(path); // 将当前组合添加到结果集中
            return;
        }
        // 循环遍历候选数组
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            // 剪枝：避免重复组合
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            sum += candidates[i]; // 更新当前和
            path.push_back(candidates[i]); // 将当前元素添加到组合中
            used[i] = true; // 标记当前元素已使用
            backtracking(candidates, target, sum, i + 1, used); // 递归调用，处理下一个元素
            used[i] = false; // 回溯，标记当前元素未使用
            sum -= candidates[i]; // 回溯，移除上一步添加的元素
            path.pop_back(); // 回溯，移除上一步添加的元素
        }
    }

public:
    // 主函数：生成目标和的组合，避免重复
    vector<vector<int>> combinationSum2(vector<int> &candidates, int target) {
        vector<bool> used(candidates.size(), false); // 用于标记元素是否已使用
        sort(candidates.begin(), candidates.end()); // 对候选数组进行排序
        backtracking(candidates, target, 0, 0, used); // 从第一个元素开始回溯
        return result;
    }
};

分割回文串

题目描述

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

解题思路

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

参数：
- const string& s：输入的字符串。
- int startIndex：当前处理的子串的起始位置。
返回值：无返回值，直接修改类成员 result 来保存所有可能的分割方案。

2. 递归函数的终止条件

当 startIndex >= s.size() 时，说明已经遍历完整个字符串，将当前分割方案 path 添加到结果集 result 中，并返回。

3. 递归函数的单层逻辑

循环遍历字符串，从 startIndex 开始。
在循环中，判断从 startIndex 到当前位置 i 的子串是否为回文串。
如果是回文串，将该子串添加到 path 中，并递归调用 backtracking 处理下一个子串。
完成递归后，执行 path.pop_back() 进行回溯，移除上一步添加的子串，以便尝试下一个子串。

回溯过程和剪枝逻辑

回溯过程：
- 在每次递归调用之后，通过 path.pop_back() 撤销之前的选择（即移除了最后一个子串），这样就可以在接下来的循环迭代中尝试其他可能的子串，从而枚举所有可能的分割方案。
剪枝逻辑：
- 在循环中，通过 isPalindrome 函数判断当前子串是否为回文串，如果不是回文串，则跳过该子串，避免不必要的递归调用。这个条件确保了只有回文子串才会被添加到当前分割方案中，从而避免了非回文子串的无效分割。

代码实现

测试地址：

class Solution {
private:
    vector<vector<string>> result; // 用于保存所有可能的分割方案
    vector<string> path; // 用于保存当前的分割方案

    // 回溯函数
    void backtracking(const string& s, int startIndex) {
        // 终止条件：如果起始位置已经大于s的大小，说明已经找到了一组分割方案
        if (startIndex >= s.size()) {
            result.push_back(path); // 将当前分割方案添加到结果集中
            return;
        }
        // 循环遍历字符串
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) { // 是回文子串
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str); // 将回文子串添加到当前分割方案中
            } else { // 不是回文，跳过
                continue;
            }
            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经添加的子串
        }
    }

    // 判断是否为回文子串
    bool isPalindrome(const string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s[i] != s[j]) {
                return false;
            }
        }
        return true;
    }

public:
    // 主函数：分割回文串
    vector<vector<string>> partition(string s) {
        result.clear(); // 清空结果集
        path.clear(); // 清空当前分割方案
        backtracking(s, 0); // 从第一个字符开始回溯
        return result;
    }
};

C1aySec

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
第七章回溯算法part02

给你一个的整数数组candidates和一个目标整数target，找出candidates中可以使数字和为目标数target的所有，并以列表形式返回。你可以按返回这些组合。candidates中的数字可以。如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为target的不同组合数少于150个。
复制链接

扫一扫