491.递增子序列

题目连接：491. 递增子序列

思路：将问题抽象为树形结构，使用回溯法。注意去重逻辑。

class Solution {
    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums, 0);
        return res;
    }
    public void backtracking(int[] nums, int start) {
        if (path.size() >= 2) {
            res.add(new ArrayList<>(path));
        }
        List<Integer> used = new ArrayList<>();
        for (int i = start; i < nums.length; i++) {
            if (!used.isEmpty() && used.contains(nums[i])) continue; // 同一树层去重。
            if (path.isEmpty() || nums[i] >= path.get(path.size() - 1)) {
                used.add(nums[i]);
                path.add(nums[i]);
            } else {
                continue;
            }
            backtracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

可以将去重数组变为哈希表map来降低时间。

46.全排列

题目链接：46. 全排列

思路：将问题抽象成树形结构，使用回溯法搜索结果。

class Solution {
    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        backtracking(nums);
        return res;
    }
    public void backtracking(int[] nums) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (!path.isEmpty() && path.contains(nums[i])) continue;
            path.add(nums[i]);
            backtracking(nums);
            path.remove(path.size() - 1);
        }
    }
}

47.全排列II

题目链接：47. 全排列 II

思路：将问题抽象成树形结构，同一树层需要去重，同一树枝上也要判断是否使用过（注意这里是如何判断的）

class Solution {
    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();
    private Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
            //System.out.println(map.get(nums[i]));
        }
        backtracking(nums);
        return res;
    }
    public void backtracking(int[] nums) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        List<Integer> used = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            // 同一树层去重
            if (!used.isEmpty() && used.contains(nums[i])) continue;
            if (map.get(nums[i]) == 0) continue;
            path.add(nums[i]);
            map.put(nums[i], map.get(nums[i]) - 1);
            used.add(nums[i]);
            backtracking(nums);
            map.put(nums[i], map.get(nums[i]) + 1);
            path.remove(path.size() - 1);     
        }
    }
}

随想录网站中的解法，直接用一个数组来判断是否使用过是比哈希表快的。

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++) {
            // used[i - 1] == true，说明同⼀树⽀nums[i - 1]使⽤过
            // used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过
            // 如果同⼀树层nums[i - 1]使⽤过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            //如果同⼀树⽀nums[i]没使⽤过开始处理
            if (used[i] == false) {
                used[i] = true;//标记同⼀树⽀nums[i]使⽤过，防止同一树枝重复使用
                path.add(nums[i]);
                backTrack(nums, used);
                path.remove(path.size() - 1);//回溯，说明同⼀树层nums[i]使⽤过，防止下一树层重复
                used[i] = false;//回溯
            }
        }
    }
}