231013刷题记录_组合总和、切割

黑蚊子多_

已于 2023-10-14 11:40:28 修改

阅读量24

点赞数

分类专栏：刷题日记文章标签：数据结构 java 算法

于 2023-10-13 16:48:23 首次发布

本文链接：https://blog.csdn.net/why_so_serious__/article/details/133811050

版权

刷题日记专栏收录该内容

28 篇文章 0 订阅

订阅专栏

231013刷题记录
参考代码代码随想录来刷的
关键词：回溯、组合总和、切割

1 39. 组合总和

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

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

对于给定的输入，保证和为 target 的不同组合数少于 150 个。
在这里插入图片描述

错误思路
我一开始看到同一个数字可以无限制重复被选取，就想的是每个for循环遍历的是整个数组。

于是写出了下面代码

public class Solution {
    private List<List<Integer>> result;
    private List<Integer> path;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new ArrayList<>();
        backtracking(candidates, target);
        return result;
    }
    private void backtracking(int[] candidates, int target) {
        if (target == 0) {
            result.add(new ArrayList<>(path));
            return;
        }
        if (target < 0)
            return;
        for (int i = 0; i < candidates.length; i++) {
            path.add(candidates[i]);
            backtracking(candidates, target - candidates[i]);
            path.remove(path.size() - 1);
        }
    }

}

这种思路显然是有问题的，因为会出现重复的组合。
在这里插入图片描述
为什么会出现这个问题呢？
因为我将组合问题和该题目中的同一个数字可以无限制重复被选取混为一谈了。

组合问题是说（2，3）和（3，2）是同一个组合，即第一个数选了3后，第二个数就不能选2了。
同一个数字可以无限制重复被选取是说，第一个数选了2之后，第二个数还可以选2。

意思就是说我一开始的思路就错了，有点混乱。for循环不能遍历整个数组。应当遍历的是当前数（题意如此，同一个数可以被选取多次），及当前数后面的数（组合问题，2、3和3、2是同一个组合）。

细节：对和的处理方式

最次的一种方式：遍历path，求和，判断是否等于target；
稍好的一种方式，递归函数中加一个参数sum，用于记录当前和；
最好的方式，递归调用的时候，传的target为target减去当前值。

class Solution {
    private List<List<Integer>> result;
    private List<Integer> path;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new ArrayList<>();
        backtracking(candidates, target, 0);
        return result;
    }
    private void backtracking(int[] candidates, int target, int startIndex) {
        if (target == 0) {
            result.add(new ArrayList<>(path));
            return;
        }
        if (target < 0)
            return;
        for (int i = startIndex; i < candidates.length; i++) {
            path.add(candidates[i]);
            backtracking(candidates, target - candidates[i], i);
            path.remove(path.size() - 1);
        }
    }
}

剪枝，优化。
如果target-当前值<0，表示当前结点处的累加和已经大于target了，没必要往当前结点的下一层走了；而且数组中的数都大于0，且是升序（提前给数组排序），故也没必要去访问当前结点的兄弟结点了，for循环中直接break即可。
请添加图片描述

class Solution {
    private List<List<Integer>> result;
    private List<Integer> path;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new ArrayList<>();
        Arrays.sort(candidates);
        backtracking(candidates, target, 0);
        return result;
    }
    private void backtracking(int[] candidates, int target, int startIndex) {
        if (target == 0) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            if (target - candidates[i] < 0) break;
            path.add(candidates[i]);
            backtracking(candidates, target - candidates[i], i);
            path.remove(path.size() - 1);
        }
    }
}

2 40.组合总和II

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

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

注意：解集不能包含重复的组合。
在这里插入图片描述
题意关键点：

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

数组可存在相同的数字意味着，使用之前的方法可能会出现相同的组合。
例如，示例2中，用老方法，会输出3个（1，2，2），重复了。
如何解决呢？
candidates 中可存在相同的数字，意味着相同的数字是可以用的，但也是不可用的。哈哈
关键是要区分什么时候可以用，什么时候不能用。
如果相同的数字不在同一层，即可使用；
如果相同的数字在同一层，则不能使用已经使用过的相同的数字。
在这里插入图片描述

class Solution {
    private List<List<Integer>> result;
    private List<Integer> path;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new ArrayList<>();
        Arrays.sort(candidates);
        backtracking(candidates, target, 0);
        return result;
    }
    private void backtracking(int[] candidates, int target, int startIndex) {
        if (target == 0) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            // 去重
            if (i > startIndex && candidates[i] == candidates[i - 1])
                continue;
            // 剪枝
            if (target - candidates[i] < 0) break;
            path.add(candidates[i]);
            backtracking(candidates, target - candidates[i], i + 1);
            path.remove(path.size() - 1);
        }
    }
}

131.分割回文串

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

回文串是正着读和反着读都一样的字符串。
在这里插入图片描述
一开始感觉毫无头绪，代码随想录上说得好

我们平时在做难题的时候，总结出来难究竟难在哪里也是一种需要锻炼的能力。
一些同学可能遇到题目比较难，但是不知道题目难在哪里，反正就是很难。其实这样还是思维不够清晰，这种总结的能力需要多接触多锻炼。
本题我相信很多同学主要卡在了第一个难点上：就是不知道如何切割，甚至知道要用回溯法，也不知道如何用。也就是没有体会到按照求组合问题的套路就可以解决切割。

该题的思路就是要将切割问题转化为组合问题。

在这里插入图片描述

class Solution {
    private List<List<String>> result;
    private List<String> temp;
    public List<List<String>> partition(String s) {
        result = new ArrayList<>();
        temp = new ArrayList<>();
        backtracking(s, 0);
        return result;
    }
    private void backtracking(String s, int beginIndex) {
        if (beginIndex >= s.length()) {
            result.add(new ArrayList<>(temp));
            return;
        }
        for (int i = beginIndex; i < s.length(); i++) {
            // 当前字串不是回文，则跳过
            if (!isPalindrome(s.substring(beginIndex, i + 1)))
                continue;
            temp.add(s.substring(beginIndex, i + 1));
            backtracking(s, i + 1);
            temp.remove(temp.size() - 1);
        }
    }
    private boolean isPalindrome(String s) {
        int left = 0;
        int right = s.length() - 1;
        while (left <= right) {
            if (s.charAt(left) != s.charAt(right))
                return false;
            left++;
            right--;
        }
        return true;
    }
}