代码随想录算法训练营第二十七天| 39. 组合总和 40.组合总和II 131.分割回文串

文章介绍了使用回溯算法解决组合总和问题,允许元素无限重复选取,并提供了回溯模板和剪枝操作。接着讨论了组合总和II问题,强调了去重的关键,通过used数组实现。最后提到了分割回文串问题,展示了如何结合回溯处理切割和回文判断的问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

39. 组合总和

题目链接

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

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

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

在这里插入图片描述
**思路:**回溯模板解决:
1、求组合问题可以用回溯法直接套模板改终止条件和相关的条件即可
2、因为元素可以被重复选取,那么模板中的startIndex的位置,在递归的时候直接用 i 即可,多次调用

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void backtracking(vector<int>& nums, int target, int startIndex) {
        if (sum > target) {
            return;
        }
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < nums.size(); i++) {
            sum += nums[i];
            path.push_back(nums[i]);
            backtracking(nums, target, i);// 关键点:不用i+1了,表示可以重复读取当前的数
            sum -= nums[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0);
        return result;
    }
};

剪枝操作,数组排完序后,如果相加的和大于了target,那么就不再继续循环了

// 如果 sum + candidates[i] > target 就终止遍历
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)

总结

组合没有数量要求
元素可无限重复选取

**关键点:**不用i+1了,表示可以重复读取当前的数
在求和问题中,排序之后加剪枝是常见的套路!

组合总和II

题目链接

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

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

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

在这里插入图片描述

思路: 回溯 + 去重

1、拿到本题,和上一题不一样,本题不能够出现相同的组合,并且每个元素只能使用依次,所以关键的点在于去重
2、根据代码随想录卡哥的 “树层去重和树枝去重”,构建一个used数组

class Solution {
public:
    // 去重是大难点
    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void backtracking(vector<int>& nums, int target, int startIndex, vector<bool> & used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < nums.size() && sum + nums[i] <= target; i++) {
            if (i > 0 && nums[i] == nums[i-1] && used[i-1] == false) {
                continue;
            }

            sum += nums[i];
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, target, i+1, used);
            sum -= nums[i];
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<bool> used(candidates.size(), false);
        backtracking(candidates, target, 0, used);
        return result;
    }
};

总结: used数组最开始不是很好理解,还要多看代码随想录的案例,这样才能够AC这道题。

131.分割回文串

题目链接

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

回文串 是正着读和反着读都一样的字符串。
在这里插入图片描述

思路: 这题属于切割问题,第一次做没有那么简单,但是套回溯模板还是能做一部分

本题这涉及到两个关键问题:
1、切割问题,有不同的切割方式
2、判断回文

组合问题:选取一个a之后,在bcdef中再去选取第二个,选取b之后在cdef中再选取第三个…。
切割问题:切割一个a之后,在bcdef中再去切割第二段,切割b之后在cdef中再切割第三段…。

在这里插入图片描述

回溯三部曲
1、递归函数参数
本题递归函数参数还需要startIndex,因为切割过的地方,不能重复切割,和组合问题也是保持一致的。

vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {

2、递归函数终止条件
在这里插入图片描述
切割线是关键
在这里插入图片描述

void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小,说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
}

3、单层搜索的逻辑
首先判断这个子串是不是回文,如果是回文,就加入在vector path中,path用来记录切割过的回文子串。

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();        // 回溯过程,弹出本次已经填在的子串
}

注意切割过的位置,不能重复切割,所以,backtracking(s, i + 1); 传入下一层的起始位置为i + 1。

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;
    }
};

总结:这道题在卡哥代码随想录上有优化版本,在二刷的时候做完动态规划可以继续看看。我做这道题只会了模板,很害怕下次再遇到这种题目又不会做了,所以还要加强练习和学习。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值