力扣labuladong一刷day6共8题

力扣labuladong一刷day6共8题

总结

回溯一共就三类，分为组合、子集、排列。其中组合与子集又基本一致。
这三类又有其他变体，变体主要就是约束条件，共有三类：
①、元素无重，不可重复选。
②、元素可重，不可重复选。
③、元素无重，可重复选。

一、78. 子集

题目链接：https://leetcode.cn/problems/subsets/
思路：求全部子集，即所有节点都收集，套模板即可。

class Solution {
    List<List<Integer>> arrayLists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backTracking(nums, 0);
        return arrayLists;
    }

    void backTracking(int[] nums, int index) {
        arrayLists.add(new ArrayList<>(list));
        for (int i = index; i < nums.length; i++) {
            list.add(nums[i]);
            backTracking(nums, i+1);
            list.remove(list.size()-1);
        }
    }
}

二、77. 组合

题目链接：https://leetcode.cn/problems/combinations/
思路：组合和子集问题基本没什么区别，无非是限定收集的深度。

class Solution {
     List<List<Integer>> arrayLists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        backTracking(n, k,1);
        return arrayLists;
    }
    void backTracking(int n, int k, int index) {
        if (list.size() >= k) {
            arrayLists.add(new ArrayList<>(list));
            return;
        }
        for (int i = index; i <= n-(k-list.size())+1; i++) {
            list.add(i);
            backTracking(n, k, i+1);
            list.remove(list.size()-1);
        }
    }
}

三、46. 全排列

题目链接：https://leetcode.cn/problems/permutations/
思路：全排列，本身无重复数字，无需去重，全排列不需要指定起始点，但需要有一个used数组来进行纵向去重。

class Solution {
    
   List<List<Integer>> arrayLists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        boolean[] used = new boolean[nums.length];
        backTracking(nums, used);
        return arrayLists;
    }
    void backTracking(int[] nums, boolean[] used) {
        if (list.size() == nums.length) {
            arrayLists.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue;
            list.add(nums[i]);
            used[i] = true;
            backTracking(nums, used);
            used[i] = false;
            list.remove(list.size()-1);
        }
    }


}

四、90. 子集 II

题目链接：https://leetcode.cn/problems/subsets-ii/
思路：本题元素可重但不可复选，也就是纵向可以重复，横向不行，横向需要去重，首先先排序，同一个节点内，如果有重复只选择第一个。

class Solution {
  List<List<Integer>> arrayLists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backTracking(nums, 0);
        return arrayLists;
    }
    void backTracking(int[] nums, int index) {
        arrayLists.add(new ArrayList<>(list));
        for (int i = index; i < nums.length; i++) {
            if (i>index && nums[i]==nums[i-1])continue;
            list.add(nums[i]);
            backTracking(nums, i+1);
            list.remove(list.size()-1);
        }
    }
}

五、40. 组合总和 II

题目链接：https://leetcode.cn/problems/combination-sum-ii/
思路：组合和子集没什么差别也是树层去重，另外注意剪枝sum+nums[i] <= target。

class Solution {
   List<List<Integer>> arrayLists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backTracking(candidates , target, 0);
        return arrayLists;
    }
 void backTracking(int[] nums, int target, int index) {
        if (sum == target) {
            arrayLists.add(new ArrayList<>(list));
            return;
        }
        for (int i = index; i < nums.length && sum+nums[i] <= target; i++) {
            if (i>index && nums[i] == nums[i-1]) continue;
            sum += nums[i];
            list.add(nums[i]);
            backTracking(nums, target, i+1);
            sum -= nums[i];
            list.remove(list.size()-1);
        }
    }
}

六、47. 全排列 II

题目链接：https://leetcode.cn/problems/permutations-ii/
思路：全排列不指定起始位置，故需要纵向去重；有重复元素故需要横向去重。
纵向去重用if (used[i]) continue;来解决。
横向去重用if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;来解决。因为只要是递归回来了used就是false，递归回来了也就开始for的横向了。

class Solution {
  List<List<Integer>> arrayLists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    boolean[] used = null;
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        used = new boolean[nums.length];
        backTracking(nums);
        return arrayLists;
    }

    void backTracking(int[] nums) {
        if (list.size() == nums.length) {
            arrayLists.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue;
            if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) continue;
            used[i] = true;
            list.add(nums[i]);
            backTracking(nums);
            used[i] = false;
            list.remove(list.size()-1);
        }
    }
}

七、39. 组合总和

题目链接：https://leetcode.cn/problems/combination-sum/
思路：本题元素无重复可复选。可复选想避免重复组合，就是不要回头，之前的组合和子集都递归i+1，这样就不会重复用之前的元素，就不会出现重复，当前是要求一个数可以重复用，那么递归就是i不再加1.

class Solution {
   List<List<Integer>> arrayLists = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        backTracking(candidates, target, 0);
        return arrayLists;
    }

    void backTracking(int[] nums, int target, int index) {
        if (sum == target) {
            arrayLists.add(new ArrayList<>(list));
            return;
        }
        for (int i = index; i < nums.length && sum + nums[i] <= target; i++) {
            sum += nums[i];
            list.add(nums[i]);
            backTracking(nums, target, i);
            sum -= nums[i];
            list.remove(list.size()-1);
        }
    }
}

八、排列（元素无重可复选）

题目链接：无链接
思路：去掉去重的used数组就行。

class Solution {

    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();

    public List<List<Integer>> permuteRepeat(int[] nums) {
        backtrack(nums);
        return res;
    }

    // 回溯算法核心函数
    void backtrack(int[] nums) {
        // base case，到达叶子节点
        if (track.size() == nums.length) {
            // 收集叶子节点上的值
            res.add(new LinkedList(track));
            return;
        }

        // 回溯算法标准框架
        for (int i = 0; i < nums.length; i++) {
            // 做选择
            track.add(nums[i]);
            // 进入下一层回溯树
            backtrack(nums);
            // 取消选择
            track.removeLast();
        }
    }
}