回溯——排列组合

8 篇文章 0 订阅

1.组合(结果不区分顺序)

1.同一个集合求组合需要startindex

需要startindex

1.元素可以重复使用

startindex为i

例:

lc39[组合总和] 给定一个无重复元素的数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明:

  • 所有数字(包括 target)都是正整数。
  • 解集不能包含重复的组合。

示例 1: 输入:candidates = [2,3,6,7], target = 7, 所求解集为: [ [7], [2,2,3]

示例 2: 输入:candidates = [2,3,5], target = 8, 所求解集为: [2,2,2,2],2,3,3],3,5]

class Solution {

    LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> temp = new LinkedList<>();
    int[] candidates;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        this.candidates = candidates;
        helper(0,target);
        return res;
    }

    void helper(int index,int target){
        if (target == 0){
            res.add(new LinkedList<>(temp));
            return;
        }

        for (int i = index; i < candidates.length; i++) {
            temp.add(candidates[i]);
            if (target - candidates[i] >= 0){
                helper(i,target - candidates[i]);
            }
            temp.removeLast();
        }
    }
   
}

关于自己的错误解答:index从0开始。

例如candidates = [1,2],

第一层为1,第二层可以为1,2。

第一层为2,第二层还是可以为1,2。

可以看到其中的[1,2] [2,1]是重复了的。

2.元素不能重复使用

startindex为i+1

lc77[组合] 给定两个整数 n 和 k,返回 1 … n 中所有可能的 k 个数的组合。

示例:

输入: n = 4, k = 2
输出:[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],]

public class Solution {
    List<List<Integer>> res;
    LinkedList<Integer> path;
    int n;
    int k;

    public List<List<Integer>> combine(int n, int k) {
        res = new ArrayList<>();
        if (k <= 0 || n < k) {
            return res;
        }
        this.k = k;
        this.n = n;
        path = new LinkedList<>();
        dfs(1);
        return res;
    }

    private void dfs(int index) {
        if (path.size() == k) {
            res.add(new ArrayList<>(path));
            return;
        }
        //不是i <= n的原因:输入6,4,如果目前结果集中已有1个元素,则只需要遍历到4(上限)即可,因为从5/6开始无法凑够4个数
        //也就是最小可选范围需要小于k - size
        //最小可选范围 = n - 上限 + 1
        //n - 上限 + 1 = k - size
        //上限 = n + 1 - (k - size)
        for (int i = index; i <= n + 1 - (k - path.size()); i++) {
            path.addLast(i);
            dfs(i + 1);
            path.removeLast();
        }
    }
}

lc40[组合总和II] 给定一个数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。

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

说明:

  • 所有数字都是正整数。
  • 解集不能包含重复的组合。

示例 1: 输入: candidates = [10,1,2,7,6,1,5], target = 8, 所求解集为: [[1, 7],[1, 2, 5],[2, 6],[1, 1, 6]]

示例 2: 输入: candidates = [2,5,2,1,2], target = 5, 所求解集为: [[1,2,2],[5]]

需要注意数组元素重复,但结果不允许重复。所以需要对于树层去重,树枝不需去重。

class Solution {

    LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> temp = new LinkedList<>();
    int[] candidates;
    boolean[] used;

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        this.candidates = candidates;
        Arrays.sort(candidates);
        helper(0,target);
        return res;
    }

    void helper(int index,int target){
        if (target == 0){
            res.add(new ArrayList<>(temp));
            return;
        }


        for (int i = index; i < candidates.length && target - candidates[i] >= 0; i++) {
            //当i=index时,说明遇到的是同一层的第一个,i>index时,遇到的是同一层的非第一个,需要跳过。
            if (i > index && candidates[i - 1] == candidates[i]){
                continue;
            }
            temp.add(candidates[i]);
            helper(i + 1,target - candidates[i]);
            temp.removeLast();
        }
    }
}
//使用标记数组,认真看,还是很好理解的
class Solution {
    LinkedList<Integer> path = new LinkedList<>();
    List<List<Integer>> ans = new ArrayList<>();
//    标志数组,用来辅助判断同层节点是否已经遍历
    boolean[] used;
    int sum = 0;

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        used = new boolean[candidates.length];
        // 为了将重复的数字都放到一起,所以先进行排序
        Arrays.sort(candidates);
        backTracking(candidates, target, 0);
        return ans;
    }

    private void backTracking(int[] candidates, int target, int startIndex) {
        if (sum == target) {
            ans.add(new ArrayList(path));
        }
        for (int i = startIndex; i < candidates.length; i++) {
            if (sum + candidates[i] > target) {
                break;
            }
            //如果是同一层,used在上一步的回溯中设为false,相同的数跳过
            //同一枝,used是true,相同的数不需要跳过
            if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1]) {
                continue;
            }
            used[i] = true;
            sum += candidates[i];
            path.add(candidates[i]);
            // 每个节点仅能选择一次,所以从下一位开始
            backTracking(candidates, target, i + 1);
            used[i] = false;
            sum -= candidates[i];
            path.removeLast();
        }
    }
}

lc216[组合总和III] 找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字。

说明:

  • 所有数字都是正整数。
  • 解集不能包含重复的组合。

示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]]

示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]]

class Solution {

    LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> temp = new LinkedList<>();
    int n;
    int k;

    public List<List<Integer>> combinationSum3(int k, int n) {
        this.n = n;
        this.k = k;
        dfs(1,0);
        return res;
    }

    void dfs(int index,int count){

        if (count == n && temp.size() == k){
            res.add(new LinkedList<>(temp));
            return;
        }
        for (int i = index; i <= 9; i++) {
            temp.add(i);
            dfs(i + 1,count+i);
            temp.removeLast();
        }
    }
}

2.不同集合求组合不需要startindex

lc17[电话号码的数字组合] 给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。

示例:

  • 输入:“23”
  • 输出:[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].
class Solution {
    //设置全局列表存储最后的结果
    List<String> list = new ArrayList<>();
    //每次迭代获取一个字符串,所以会设计大量的字符串拼接,所以这里选择更为高效的 StringBuild
    StringBuilder temp = new StringBuilder();
    //初始对应所有的数字,为了直接对应2-9,新增了两个无效的字符串""
    String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    String digits;
    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return list;
        }
        this.digits = digits;
        //迭代处理
        backTracking(0);
        return list;
    }

    void backTracking(int index){
        if (index == digits.length()){
            list.add(new String(temp));
            return;
        }
        
        String curString = numString[digits.charAt(index) - '0'];
        for (int i = 0; i < curString.length(); i++) {
            temp.append(curString.charAt(i));
            backTracking(index + 1);
            temp.deleteCharAt(temp.length() - 1);
        }
    }
}

3.子集(特殊的组合)

如果把子集问题、组合问题、排列问题、分割问题都抽象为一棵树的话,那么组合问题和分割问题都是收集树的叶子节点,而子集问题是找树的所有节点

lc78[子集] 给定一组不含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。

说明:解集不能包含重复的子集。

示例: 输入: nums = [1,2,3] 输出: [[3],[1],[2],1,2,3],1,3],2,3],1,2]]

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    Deque<Integer> queue = new ArrayDeque<>();
    int[] nums;

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if (nums.length == 0){
            return res;
        }
        this.nums = nums;
        dfs(0);
        return res;
    }

    void dfs(int index){
        if (index <= nums.length){
            res.add(new ArrayList<>(queue));
        }
        for (int i = index; i < nums.length; i++) {
            queue.add(nums[i]);
            dfs(i + 1);
            queue.removeLast();
        }
    }
}

lc90[子集II] 给定一个可能包含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。

说明:解集不能包含重复的子集。

示例:

  • 输入: [1,2,2]
  • 输出: [2], [1], [1,2,2], [2,2], [1,2], []
class Solution {

    List<List<Integer>> res = new LinkedList<>();
    Deque<Integer> queue = new ArrayDeque<>();
    int[] nums;

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if (nums.length == 0){
            return res;
        }
        this.nums = nums;
        Arrays.sort(nums);
        dfs(0);
        return res;
    }


    void dfs(int index){
        if (index <= nums.length){
            res.add(new ArrayList<>(queue));
        }

        for (int i = index; i < nums.length; i++) {
            //只留取同一层的第一个相同的数。
            //当i大于index,且与i-1相等说明同一层中当前数与前一个数相等。
            if (index < i && nums[i] == nums[i - 1]){
                continue;
            }
            queue.add(nums[i]);
            dfs(i + 1);
            queue.removeLast();
        }
    }
}

lc491[递增子序列] 给定一个整型数组, 你的任务是找到所有该数组的递增子序列,递增子序列的长度至少是2。

示例:

  • 输入: [4, 6, 7, 7]
  • 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

说明:

  • 给定数组的长度不会超过15。
  • 数组中的整数范围是 [-100,100]。
  • 给定数组中可能包含重复数字,相等的数字应该被视为递增的一种情况。

可以使用used数组,上述情况中属于纵向递归可以重复,横向遍历不能重复,所以used写在函数里,每次递归会创建新的used数组。

如果将used写在外边(全局变量),则在整棵树中都不能重复

//要求递增所以不能给原数组排序
class Solution {
    private List<Integer> path = new ArrayList<>();
    private List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums,0);
        return res;
    }

    private void backtracking (int[] nums, int start) {
        if (path.size() > 1) {
            res.add(new ArrayList<>(path));
        }

        //题目中-100 <= nums[i] <= 100
        int[] used = new int[201];
        for (int i = start; i < nums.length; i++) {
            if (!path.isEmpty() && nums[i] < path.get(path.size() - 1) ||
                    (used[nums[i] + 100] == 1)) {
            	continue;   
            }
            used[nums[i] + 100] = 1;
            path.add(nums[i]);
            backtracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

并且,原数组中有重复数的时候不能直接用数组下标来标记数字是否使用。例如原数组nums[] = {1,1},used[] = {1,0}只能说明第一个1被使用,第二个1还是可以使用,失去了去重的意义。以496题为例可以用:used[nums[i] + 100] == 1来标记。

此题也可以使用set集合来去重,但set涉及到hash计算,效率远低于数组,在数组范围允许的情况下最好还是使用数组较好。

4.切割问题(特殊的组合)

lc131[分割回文串] 给定一个字符串 s,将 s 分割成一些子串,使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例: 输入: “aab” 输出: [ [“aa”,“b”], [“a”,“a”,“b”]

切割问题,也可以抽象为一棵树形结构,如图:

[(img-YO8t7Jj8-1674273086023)(D:\MK图片\131.分割回文串.jpg)]

递归用来纵向遍历,for循环用来横向遍历,切割线(就是图中的红线)切割到字符串的结尾位置,说明找到了一个切割方法。

此时可以发现,切割问题的回溯搜索的过程和组合问题的回溯搜索的过程是差不多的。

class Solution {
    List<List<String>> lists = new ArrayList<>();
    Deque<String> deque = new LinkedList<>();

    public List<List<String>> partition(String s) {
        backTracking(s, 0);
        return lists;
    }

    private void backTracking(String s, int startIndex) {
        //如果起始位置大于s的大小,说明找到了一组分割方案
        if (startIndex >= s.length()) {
            lists.add(new ArrayList(deque));
            return;
        }
        for (int i = startIndex; i < s.length(); i++) {
            //如果是回文子串,则记录
            if (isPalindrome(s, startIndex, i)) {
                String str = s.substring(startIndex, i + 1);
                deque.addLast(str);
            } else {
                continue;
            }
            //起始位置后移,保证不重复
            backTracking(s, i + 1);
            deque.removeLast();
        }
    }
    //判断是否是回文串
    private boolean isPalindrome(String s, int startIndex, int end) {
        for (int i = startIndex, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }
}

lc93[分割回文串] 给定一个只包含数字的字符串,复原它并返回所有可能的 IP 地址格式。

有效的 IP 地址 正好由四个整数(每个整数位于 0 到 255 之间组成,且不能含有前导 0),整数之间用 ‘.’ 分隔。

例如:“0.1.2.201” 和 “192.168.1.1” 是 有效的 IP 地址,但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效的 IP 地址。

示例 1:

  • 输入:s = “25525511135”
  • 输出:[“255.255.11.135”,“255.255.111.35”]
class Solution {

    List<String> res = new ArrayList<>();
    Deque<String> path = new ArrayDeque<>(4);
    String s;
    public List<String> restoreIpAddresses(String s) {
        this.s = s;
        dfs(0, 4);
        return res;
    }

    void dfs(int index, int sum){
        //当前有4段且长度刚好为s长度
        if (sum == 0 && index == s.length()){
            res.add(String.join(".", path));
        }

        for (int i = index; i < s.length(); i++) {
            //长度小于三且是回文串
            if (i - index < 3 && judgeNumber(s,index,i)){
                path.add(s.substring(index,i+1));
                dfs(i+1,sum-1);
                path.removeLast();
            }
        }

    }

    public boolean judgeNumber(String s, int left, int right){
        int len = right - left + 1;
        //当前为0开头的且长度大于1的数字需要剪枝
        if(len>1 && s.charAt(left)=='0'){
            return false;
        }
        //将当前截取的字符串转化成数字
        int res = len<=0 ? 0 : Integer.parseInt(s.substring(left, right+1));
        //判断截取到的数字是否符合
        return res>=0 && res<=255;
    }
}

在这里插入图片描述

2.排列(结果区分顺序)

首先排列是有序的,也就是说 [1,2] 和 [2,1] 是两个集合,这和之前分析的子集以及组合所不同的地方

可以看出元素1在[1,2]中已经使用过了,但是在[2,1]中还要在使用一次1,所以处理排列问题就不用使用startIndex了。

但排列问题需要一个used数组,标记已经选择的元素。

lc46[全排列] 给定一个没有重复数字的序列,返回其所有可能的全排列。

示例:

  • 输入: [1,2,3]
  • 输出: [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]
class Solution {

    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
    boolean[] used;
    public List<List<Integer>> permute(int[] nums) {
        if (nums.length == 0){
            return result;
        }
        used = new boolean[nums.length];
        permuteHelper(nums);
        return result;
    }

    private void permuteHelper(int[] nums){
        if (path.size() == nums.length){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++){
            if (used[i]){
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            permuteHelper(nums);
            path.removeLast();
            used[i] = false;
        }
    }
}
// 解法2:通过判断path中是否存在数字,排除已经选择的数字
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        if (nums.length == 0) return result;
        backtrack(nums, path);
        return result;
    }
    
    public void backtrack(int[] nums, LinkedList<Integer> path) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
        }
        for (int i =0; i < nums.length; i++) {
            // 如果path中已有,则跳过
            if (path.contains(nums[i])) {
                continue;
            } 
            path.add(nums[i]);
            backtrack(nums, path);
            path.removeLast();
        }
    }
}

lc47[全排列II] 给定一个可包含重复数字的序列 nums ,按任意顺序 返回所有不重复的全排列。

示例 1:

  • 输入:nums = [1,1,2]
  • 输出: [[1,1,2], [1,2,1], [2,1,1]]

示例 2:

  • 输入:nums = [1,2,3]
  • 输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示:

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10
//第一种相对较好理解
class Solution {
    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();
    private boolean[] used = null;

    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        Arrays.sort(nums);
        backtracking(nums);
        return res;
    }

    public void backtracking(int[] nums) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        
        HashSet<Integer> hashSet = new HashSet<>();//层去重,相比普通的多了个层去重
        //除了使用set去重也可以使用used[nums[i] + 100] == true来去重。
        for (int i = 0; i < nums.length; i++) {
            if (hashSet.contains(nums[i]))
                continue;
            if (used[i])//枝去重,起startindex的作用
                continue;
            hashSet.add(nums[i]);//记录元素
            used[i] = true;
            path.add(nums[i]);
            backtracking(nums);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}


//第二种
class Solution {
    //存放结果
    List<List<Integer>> result = new ArrayList<>();
    //暂存结果
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used, false);
        Arrays.sort(nums);
        backTrack(nums, used);
        return result;
    }

    private void backTrack(int[] nums, boolean[] used) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
/*
for循环保证了从数组中从前往后一个一个取值,再用if判断条件。所以nums[i - 1]一定比nums[i]先被取值和判断。如果nums[i - 1]被取值了,used[i - 1]会被置true,只有当递归再回退到这一层时再将它置false。所以当used[i - 1] == true时,说明nums[i - 1]和nums[i]分别属于两层递归中(在同一树枝中),也就是我们要用这两个数分别放在数组的两个位置,这时不需要去重。但是当used[i - 1] == false时,说明nums[i - 1]和nums[i]属于同一层递归中,此时需要去重。
*/
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //如果同⼀树枝nums[i]没使⽤过,开始处理
            if (used[i] == false) {
                used[i] = true;
                path.add(nums[i]);
                backTrack(nums, used);
                path.remove(path.size() - 1);//回溯
                used[i] = false;//回溯
            }
        }
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我顶得了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值