491. 递增子序列

class Solution {
    LinkedList<Integer> path = new LinkedList<>();
    List<List<Integer>> res = new LinkedList<>();

    public List<List<Integer>> findSubsequences(int[] nums) {
        backtrack(nums, 0);
        return res;
    }
    private void backtrack(int[] nums, int start){
        if(path.size() >= 2){
            res.add(new LinkedList<>(path));
        }

        // 用HashSet来防止重复选择相同元素
        HashSet<Integer> used = new HashSet<>(); // 每层的回溯都会建一个自己的HashSet来对本层进行去重

        for(int i = start; i < nums.length; i++){
            // 保证集合中元素是递增顺序
            if(!path.isEmpty() && path.getLast() > nums[i])continue;

            // 保证不重复使用相同元素
            if(used.contains(nums[i]))continue;

            used.add(nums[i]);
            path.add(nums[i]);
            backtrack(nums, i + 1);
            // 无需在本层的HashSet中去掉nums[i]
            path.removeLast();
        }
    }
}

46. 全排列

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        boolean[] visited = new boolean[nums.length];
        Arrays.fill(visited, false);
        backtracking(nums, visited);
        return res;
    }
    private void backtracking(int[] nums, boolean[] visited){
        if(path.size() == nums.length){
            res.add(new LinkedList<>(path));
            return;
        }
        for(int i = 0; i < nums.length; i++){
            if(visited[i]){
                // nums[i] 已经在 path 中，跳过
                continue;
            }

            path.add(nums[i]);
            visited[i] = true;
            backtracking(nums, visited);
            path.removeLast();
            visited[i] = false;
        }
    }
}

47. 全排列 II

class Solution {
    LinkedList<Integer> path = new LinkedList<>();
    List<List<Integer>> res = new LinkedList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used, false);
        backtrack(nums, used);
        return res;
    }
    private void backtrack(int[] nums, boolean[] used){
        if(path.size() == nums.length){
            res.add(new LinkedList<>(path));
        }

        for(int i = 0; i < nums.length; i++){
            if(used[i] == true)continue;
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)continue;

            used[i] = true;
            path.add(nums[i]);
            backtrack(nums, used);
            used[i] = false;
            path.removeLast();
        }
    }
}