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

Jasmine-Lily

已于 2023-01-31 16:08:48 修改

阅读量138

点赞数 1

分类专栏： Algorithms 文章标签：算法 leetcode c++

于 2023-01-04 13:51:07 首次发布

本文链接：https://blog.csdn.net/weixin_44410704/article/details/128546874

版权

Algorithms 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

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

题目列表

39.组合总和
40.组合总和II
131.分割回文串

39.组合总和

代码随想录地址：

https://programmercarl.com/0039.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8C.html

题目

给你一个 无重复元素 的整数数组 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 <= candidates.length <= 30
2 <= candidates[i] <= 40
candidates 的所有元素 互不相同
1 <= target <= 40

思路

在这里插入图片描述

剪枝

在这里插入图片描述

要使用start，为什么？

我举过例子，如果是一个集合来求组合的话，就需要startIndex，例如：77.组合 (opens new window)，216.组合总和III (opens new window)。

如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合

代码

/*
 * @lc app=leetcode.cn id=39 lang=cpp
 *
 * [39] 组合总和
 */

// @lc code=start
class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
    //原来想的不要start这个参数，但是跑出来结果不对
    //因为它会往前跑，产生的结果中有的组合重复了
    void backtracking(vector<int>& candidates, int target, int sum, int start)
    {
        //终止条件
        if(sum == target)
        {
            res.push_back(path);
            return;
        }
        //单层搜索的逻辑
        for(int i = start; i < candidates.size() && sum + candidates[i] <= target; i++)
        {
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();
        }
    } 
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        res.clear();
        path.clear();
        //需要排序，因为在单层搜索逻辑中，如果遇到sum > target，for循环就结束了
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return res;
    }
};
// @lc code=end

40.组合总和II

代码随想录地址：

https://programmercarl.com/0040.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8CII.html

题目

给定一个候选人编号的集合 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 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

思路

树层去重与剪枝

在这里插入图片描述

代码

使用used数组去重

/*
 * @lc app=leetcode.cn id=40 lang=cpp
 *
 * [40] 组合总和 II
 */

// @lc code=start
class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
    //要求nums排序了的
    void backtracking(vector<int>& nums, int target, int sum, int start, vector<bool>& used)
    {
        //终止条件
        if(sum == target)
        {
            res.push_back(path);
            return;
        }
        //单层循环
        //需要对这个sum + nums[i] <= target进行剪枝
        //不然会超时
        for(int i = start; i < nums.size() && sum + nums[i] <= target; i++)
        {
            //去重操作：使用了树层去重，树枝不需要去重
            //加上!used[i-1]这个条件就是为了实现树层去重，而不要将树枝去重
            if(i > 0 && nums[i] == nums[i-1] && used[i-1] == false)
                continue;
            path.push_back(nums[i]);
            sum += nums[i];
            used[i] = true;
            backtracking(nums, target, sum, i + 1, used);
            used[i] = false;
            sum -= nums[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        res.clear();
        path.clear();
        //需要初始化used数组，最开始弄错了
        vector<bool> used(candidates.size(), false);
        //需要排序，最开始忘记了
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return res;
    }
};
// @lc code=end

使用start去重

/*
 * @lc app=leetcode.cn id=40 lang=cpp
 *
 * [40] 组合总和 II
 */

// @lc code=start
class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
    //要求nums排序了的
    void backtracking(vector<int>& nums, int target, int sum, int start)
    {
        //终止条件
        if(sum == target)
        {
            res.push_back(path);
            return;
        }
        //单层循环
        //需要对这个sum + nums[i] <= target进行剪枝
        //不然会超时
        for(int i = start; i < nums.size() && sum + nums[i] <= target; i++)
        {
            //去重操作：使用了树层去重，树枝不需要去重
            //加上!used[i-1]这个条件就是为了实现树层去重，而不要将树枝去重
            if(i > start && nums[i] == nums[i - 1])
                continue;
            path.push_back(nums[i]);
            sum += nums[i];
            backtracking(nums, target, sum, i + 1);
            sum -= nums[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        res.clear();
        path.clear();
        //需要排序，最开始忘记了
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return res;
    }
};
// @lc code=end

131.分割回文串

代码随想录地址：

https://programmercarl.com/0131.%E5%88%86%E5%89%B2%E5%9B%9E%E6%96%87%E4%B8%B2.html

题目

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

回文串 是正着读和反着读都一样的字符串。

示例 1：

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

示例 2：

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

提示：

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

思路

在这里插入图片描述

代码

/*
 * @lc app=leetcode.cn id=131 lang=cpp
 *
 * [131] 分割回文串
 */

// @lc code=start
class Solution {
private:
    vector<vector<string>> res;
    vector<string> path;
    //前闭后闭区间
    //判断字符串是否为回文字符串
    bool isPalindrome(string& s, int start, int end)
    {
        while(start <= end)
        {
            if(s[start] != s[end])
                return false;
            start++;
            end--;
        }
        return true;
    }
    void backtracking(string& s, int start)
    {
        //终止条件
        if(start >= s.size())
        {
            res.push_back(path);
            return;
        }
        //单层for循环
        for(int i = start; i < s.size(); i++)
        {            
            //判断字串是否为回文串
            if(isPalindrome(s, start, i))//如果为回文串，则将字串sub入数组path
            {
                //获取字串
                string sub = s.substr(start, i - start + 1);
                path.push_back(sub);
            }
            else//字串不是回文串，则跳过这层循环
            {
                continue;
            }
            //开始回溯
            //就是一层套一层
            backtracking(s, i + 1);
            path.pop_back();//回溯
        }
    }
public:
    vector<vector<string>> partition(string s) {
        res.clear();
        path.clear();
        backtracking(s, 0);
        return res;
    }
};
// @lc code=end

Jasmine-Lily

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
2
评论
_23LeetCode代码随想录算法训练营第二十三天-回溯算法 | 39.组合总和、40.组合总和II、131.分割回文串

_23LeetCode代码随想录算法训练营第二十三天-回溯算法 | 39.组合总和、40.组合总和II、131.分割回文串
复制链接

扫一扫