力扣题2022.10.6

1 力扣题39:组合总和

1.1 问题描述

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

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

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

1.2 思路分析

1.2.1 回溯

回溯模板，临界条件，顺序遍历，条件判断，深入，回溯。注意深入有两种操作，不加当前数，加当前数。

1.3 代码实现

1.3.1 回溯

List<List<Integer>> result = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<Integer> tempList = new ArrayList<>();
        backTrack(candidates,target,0,tempList,0);
        return result;
    }

    void backTrack(int[] candidates, int target, int tempValue, List<Integer> tempList,int index) {
        if (index==candidates.length)
            return;
        if (tempValue==target) {
            List<Integer> copyList = new ArrayList<>(tempList);
            result.add(copyList);
            return;
        }
        //不加当前数,加当前数才是正确的深入操作
        backTrack(candidates,target,tempValue,tempList,index+1);
        if (tempValue+candidates[index]<=target) {
            tempList.add(candidates[index]);
            backTrack(candidates,target,tempValue+candidates[index],tempList,index);
            tempList.remove(tempList.size()-1);
        }
    }

2 力扣题46:全排列

2.1 问题描述

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

2.2 思路分析

回溯模板，临界条件，顺序遍历，条件判断，深入，回溯。设定一个判断数组，用于条件判断。

2.3 代码实现

2.3.1 回溯

List<List<Integer>> result = new ArrayList<>();
    int[] judge = new int[1];
    public List<List<Integer>> permute(int[] nums) {
        List<Integer> tmpList = new ArrayList<>();
        judge = new int[nums.length];
        backtrack(nums,tmpList,0);
        return result;
    }

    void backtrack(int[] nums, List<Integer> tmpList, int depth) {
        if (depth==nums.length) {
            result.add(new ArrayList<Integer>(tmpList));
            return;
        }
        for (int i=0; i<nums.length; i++) {
            if (judge[i]==0) {
                judge[i] = 1;
                tmpList.add(nums[i]);
                backtrack(nums,tmpList,depth+1);
                tmpList.remove(tmpList.size()-1);
                judge[i] = 0;
            }
        }
    }