LeetCode 排列组合子集问题(回溯 + 剪枝)

46. 全排列（中等）

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        if(nums == null || nums.length == 0){
            return list;
        }
        Deque<Integer> path = new ArrayDeque<>();
        boolean[] visited = new boolean[nums.length];	//重要

        dfs(nums, visited, list, path);
        return list;
    }

    public void dfs(int[] nums, boolean[] visited, List<List<Integer>> list, Deque<Integer> path){
        if(path.size() == nums.length){
            list.add(new ArrayList<Integer>(path));
            return;
        }

        for(int i=0; i<nums.length; i++){
            if( !visited[i] ){
                path.add(nums[i]);
                visited[i] = true;
                dfs(nums, visited, list, path);
                path.removeLast();
                visited[i] = false;
            }
        }
    }
}

47. 全排列 II（中等）

class Solution {
     public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        if(nums == null || nums.length == 0){
            return list;
        }
        Deque<Integer> path = new ArrayDeque<>();
        boolean[] visited = new boolean[nums.length];	//重要
        Arrays.sort(nums);	//重要
        
        dfs(nums, visited, list, path);
        return list;
    }

    public void dfs(int[] nums, boolean[] visited, List<List<Integer>> list, Deque<Integer> path){
        if(path.size() == nums.length){
            list.add(new ArrayList<Integer>(path));
            return;
        }

        for(int i=0; i<nums.length; i++){
            if( !visited[i] ){
                // 剪枝条件：i > 0 是为了保证 nums[i - 1] 有意义
                // 写 !used[i - 1] 是因为 nums[i - 1] 在深度优先遍历的过程中刚刚被撤销选择
                if (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
                    continue;
                }
                path.add(nums[i]);
                visited[i] = true;
                dfs(nums, visited, list, path);
                path.removeLast();
                visited[i] = false;
            }
        }
    }
}

39. 组合总和（中等）

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> list = new ArrayList<>();
        ArrayDeque<Integer> queue = new ArrayDeque<>();

        Arrays.sort(candidates);	//重要
        traceBack(list, target, queue, 0, candidates);
        return list;
    }

    public void traceBack(List<List<Integer>> list, int target, ArrayDeque<Integer> queue, int start, int[] candidates){  
        if(target == 0){
            list.add(new ArrayList<>(queue));
            return;
        }
        
        for(int i=start; i<candidates.length; i++){
            // target -= candidates[i];  //错误，因为这样 target 每次都会累减
            if(target - candidates[i]< 0){
                break;
            }
            queue.offer(candidates[i]);
            traceBack(list, target-candidates[i], queue, i, candidates);  //因为可以重复，因此传入的参数是 i 
            queue.removeLast();
        }

    }
}

40. 组合总和 II（中等）

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {

        List<List<Integer>> list = new ArrayList<>();
        ArrayDeque<Integer> queue = new ArrayDeque<>();

        Arrays.sort(candidates);	//重要
        traceBack(list, target, queue, 0, candidates);
        return list;
    }

    public void traceBack(List<List<Integer>> list, int target, ArrayDeque<Integer> queue, int start, int[] candidates){
        if(target == 0){
            list.add(new ArrayList<>(queue));
            return;
        }
        
        for(int i=start; i<candidates.length; i++){
        	//剪枝
            if(target - candidates[i]< 0){
                break;
            }
            //剪枝，同层的重复元素pass掉，不同层的重复元素通过 i>start 为false，保留
            if(i>start && candidates[i] == candidates[i-1]){
                continue;
            }
            queue.offer(candidates[i]);
            traceBack(list, target-candidates[i], queue, i+1, candidates); //因为不可以重复取同一元素，因此参数是 i+1
            queue.removeLast();
        }

    }
}

77. 组合（中等）

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> list = new ArrayList<>();
        if(k < 0 || k > n){
            return list;
        }
        Deque<Integer> path = new ArrayDeque<>();
        dfs(n, k, 1, path, list); //从 1 开始
        return list;
    }

    public void dfs(int n, int k, int start, Deque<Integer> path, List<List<Integer>> list){
        if(path.size() == k){
            list.add(new ArrayList<>(path));
            return ;
        }
        // <n 即可，<n-(k-path.size())+1 是为了剪枝，因为搜索起点有上界，具体略
        for(int i=start; i<=n-(k-path.size())+1; i++){
            path.offer(i);
            dfs(n,k,i+1,path,list);
            path.removeLast();
        }

    }
}

78. 子集（中等）

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        int n = nums.length;
        List<List<Integer>> output = new ArrayList();

        for (int k = 0; k < n + 1; ++k) {
            backtrack(0, new ArrayDeque<Integer>(), nums, k, output);
        }
        return output;
    }

    public void backtrack(int first, ArrayDeque<Integer> curr, int[] nums, int k, List<List<Integer>> output) {
        if (curr.size() == k){
            output.add(new ArrayList(curr));
        }

        for (int i = first; i<nums.length; ++i) {
            curr.offer(nums[i]);
            backtrack(i + 1, curr, nums, k, output);
            curr.removeLast();
        }
    }
}

90. 子集 II（中等）

class Solution {
     public List<List<Integer>> subsetsWithDup(int[] nums) {
        int n = nums.length;
        List<List<Integer>> output = new ArrayList();
        Arrays.sort(nums); 	//重要

        for (int k = 0; k < n + 1; ++k) {
            backtrack(0, new ArrayDeque<Integer>(), nums, k, output);
        }
        return output;
    }

    public void backtrack(int first, ArrayDeque<Integer> curr, int[] nums, int k, List<List<Integer>> output) {
        if (curr.size() == k){
            output.add(new ArrayList(curr));
        }

        for (int i = first; i<nums.length; ++i) {
        	//剪枝
            if(i>first && nums[i]==nums[i-1]){
                continue;
            }
            curr.offer(nums[i]);
            backtrack(i + 1, curr, nums, k, output);
            curr.removeLast();
        }
    }
}