刷题计划day23 回溯（二）【组合总和】【组合总和 II】【分割回文串】

最新推荐文章于 2025-06-14 15:30:38 发布

哈哈哈的懒羊羊

最新推荐文章于 2025-06-14 15:30:38 发布

阅读量773

点赞数 23

分类专栏： leetcode从0开始刷题计划及刷题笔记文章标签：数据结构算法 java leetcode 蓝桥杯面试

本文链接：https://blog.youkuaiyun.com/weixin_72499901/article/details/144076741

版权

leetcode从0开始刷题计划及刷题笔记专栏收录该内容

30 篇文章

订阅专栏

⚡刷题计划day23 回溯（二）开始，回溯一共会有五个专题，敬请期待关注，可以点个免费的赞哦~

往期可看专栏，关注不迷路，

您的支持是我的最大动力🌹~

题目一：39. 组合总和

39.组合总和

(https://leetcode.cn/problems/combination-sum/description/)

本题搜索的过程抽象成树形结构如下：

回溯三部曲

1.递归函数参数

首先仍是需要定义两个全局变量，二维数组res存放结果集，数组path存放符合条件的路径。

然后说题目给出的两个参数，candidates，target。

此外还需要定义一个sum值来统计path里的总和，

还需要startIndex来控制for循环的起始位置

问：对于组合问题，什么时候需要startIndex呢？

如果是一个集合来求组合的话，就需要startIndex，例如：77.组合，216.组合总和III。

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

代码如下：

List<List<Integer>> res = new ArrayList<>();
LinkedList path = new LinkedList();
void backtracking(int[] candidates,int target,int sum,int startIndex)

2.终止条件

在如下树形结构中：

从叶子节点可以清晰看到，终止只有两种情况，sum大于target和sum等于target。

sum等于target的时候，需要收集结果，代码如下：

if(sum>target){
    return;
}
if(sum==target){
    res.add(new ArrayList<>(path));
    return;
}

3.单层搜索逻辑

单层for循环依然是从startIndex开始，搜索candidates集合。

然后注意本题元素是可重复选取的，即递归时不需要i+1（见代码）

for(int i=startIndex;i<candidates.length && candidates[i]+sum<=target;i++){
    sum += candidates[i];
    path.add(candidates[i]);
    backtracking(candidates,target,sum,i);// 关键点:不用i+1了，表示可以重复读取当前的数
    sum -= candidates[i];// 回溯
    path.removeLast();// 回溯
}

完整代码

class Solution {
     List<List<Integer>> res = new ArrayList<>();
     LinkedList path = new LinkedList();
     
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtracking(candidates,target,0,0);
        return res;
    }
    
    public void backtracking(int[] candidates,int target,int sum,int startIndex){
        if(sum>target){
            return;
        }
        if(sum==target){
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i=startIndex;i<candidates.length;i++){
            sum += candidates[i];
            path.add(candidates[i]);
            backtracking(candidates,target,sum,i);
            sum -= candidates[i];
            path.removeLast();
        }
    }
}

剪枝优化

在这个树形结构中：

对于sum已经大于target的情况，其实是依然进入了下一层递归，只是下一层递归结束判断的时候，会判断sum > target的话就返回。

其实如果已经知道下一层的sum会大于target，就没有必要进入下一层递归了。

那么可以在for循环的搜索范围上做做文章了。

对总集合排序之后，如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。

剪枝代码如下：

for(int i=startIndex;i<candidates.length && candidates[i]+sum<=target;i++)

完整代码如下：

class Solution {
     List<List<Integer>> res = new ArrayList<>();
     LinkedList path = new LinkedList();
     
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);// 需要排序
        backtracking(candidates,target,0,0);
        return res;
    }
     // 如果 sum + candidates[i] > target 就终止遍历
    public void backtracking(int[] candidates,int target,int sum,int startIndex){
        if(sum>target){
            return;
        }
        if(sum==target){
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i=startIndex;i<candidates.length && candidates[i]+sum<=target;i++){
            sum += candidates[i];
            path.add(candidates[i]);
            backtracking(candidates,target,sum,i);
            sum -= candidates[i];
            path.removeLast();
        }
    }
}

题目二：40. 组合总和 II

40.组合总和 II

(https://leetcode.cn/problems/combination-sum-ii/description/)

这道题目和 39.组合总和如下区别：

本题candidates 中的每个数字在每个组合中只能使用一次。
本题数组candidates的元素是有重复的，而 39.组合总和是无重复元素的数组candidates

最后本题和 39.组合总和要求一样，解集不能包含重复的组合。

本题的难点在于区别2中：集合（数组candidates）有重复元素，但还不能有重复的组合。

一些同学可能想了：我把所有组合求出来，再用set或者map去重，这么做很容易超时！

关于去重

对于使用过的元素，有两个维度，一个是树枝去重，一个是树层去重

根据题目，元素在同一个组合内是可以重复的，但两个组合不能相同。

所以我们要去重的应该是树层去重。

选择过程树形结构如图所示：

解题过程和之前题目差不多，不多叙述，直接见代码

class Solution {
     List<List<Integer>> res = new ArrayList<>();
     LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        bcaktracking(candidates,target,0,0);
        res.stream();
        return res;

    }
    public void bcaktracking(int[] candidates,int target,int sum,int startIndex){
        if(sum==target){
            res.add(new ArrayList<>(path));
            return;
        }
        //剪枝优化，上题有讲解
        for(int i=startIndex;i<candidates.length && sum+candidates[i]<=target;i++){
            //注意此时已经有序，去重操作
            if(i>startIndex && candidates[i]==candidates[i-1]){
                continue;
            }
            sum+=candidates[i];
            path.add(candidates[i]);
            bcaktracking(candidates,target,sum,i+1);
            sum-=candidates[i];
            path.removeLast();
        }
    }
}

题目三：131. 分割回文串

131. 分割回文串

(https://leetcode.cn/problems/palindrome-partitioning/)

此题挺有难度的。

本题这涉及到两个关键问题：

切割问题，有不同的切割方式
判断回文

一些同学可能想不清楚回溯究竟是如何切割字符串呢？

我们来分析一下切割，其实切割问题类似组合问题。

例如对于字符串abcdef：

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

感受出来了不？

所以切割问题，也可以抽象为一棵树形结构，如图：

从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。

那么在代码里什么是切割线呢？

在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。

class Solution {
    List<List<String>> res = new ArrayList<>();
    LinkedList<String> path = new LinkedList<>();
    public List<List<String>> partition(String s) {
    backtracking(s,0,new StringBuilder());
    return res;

    }
    public void backtracking(String s,int startIndex,StringBuilder sb){
        //因为是起始位置一个一个加的，所以结束时start一定等于s.length,因为进入backtracking时一定末尾也是回文，所以cur是满足条件的
        if(startIndex==s.length()){
            res.add(new ArrayList<>(path));
            return;
        }
        //像前两题一样从前往后搜索，如果发现回文，进入backtracking,起始位置后移一位，循环结束照例移除cur的末位
        for(int i=startIndex;i<s.length();i++){
            sb.append(s.charAt(i));
            if(isHuiweng(sb)){
                path.add(sb.toString());
                backtracking(s,i+1,new StringBuilder());
                path.removeLast();
            }
        }

    }
    //检查是否是回文
    public boolean isHuiweng(StringBuilder sb){
        for(int i=0;i<sb.length()/2;i++){
            if(sb.charAt(i)!=sb.charAt(sb.length()-i-1)){
                return false;
            }
        }
        return true;
    }
}

点个免费的赞吧~