93. 复原 IP 地址

题目链接：93. 复原 IP 地址

思路：切割问题，原理上还是抽象成树形结构，然后使用回溯法。

131 题的要求是：让你把字符串 s 切分成若干个合法的回文串，返回所有的切分方法。

本题的要求是：让你把字符串 s 切分成 4 个合法的 IP 数字，返回所有的切分方法。

所以我们只要把 131 题的解法稍微改改，重写一个 isValid 函数判断合法的 IP 数字，并保证整棵回溯树只有 4 层（即 path 中只有 4 个子串）即可。

public class Solution {
    private List<String> res = new ArrayList<>();
    private List<String> path = new ArrayList<>();

    public List<String> restoreIpAddresses(String s) {
        backtracking(s, 0);
        return res;
    }

    // 回溯算法框架
    private void backtracking(String s, int start) {
        if (start == s.length() && path.size() == 4) {
            // base case，走到叶子节点
            // 即整个 s 被成功分割为合法的四部分，记下答案
            res.add(String.join(".", path));
        }
        for (int i = start; i < s.length(); i++) {
            if (!isValid(s, start, i)) {
                // s[start..i] 不是合法的 ip 数字，不能分割
                continue;
            }
            if (path.size() >= 4) {
                // 已经分解成 4 部分了，不能再分解了
                break;
            }
            // s[start..i] 是一个合法的 ip 数字，可以进行分割
            // 做选择，把 s[start..i] 放入路径列表中
            path.add(s.substring(start, i + 1));
            // 进入回溯树的下一层，继续切分 s[i+1..]
            backtracking(s, i + 1);
            // 撤销选择
            path.remove(path.size() - 1);
        }
    }

    // 判断字符串s在左闭⼜闭区间[start, end]所组成的数字是否合法
    private boolean isValid(String s, int start, int end) {
        // 大于 1 位的时候，不能以 0 开头
        if (s.charAt(start) == '0' && start != end) {
            return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            // 遇到⾮数字字符不合法
            if (s.charAt(i) > '9' || s.charAt(i) < '0') {
                return false;
            }
            num = num * 10 + (s.charAt(i) - '0');
            if (num > 255) { // 如果数字⼤于255不合法
                return false;
            }
        }
        return true;
    }
}

---

78. 子集

题目链接：78. 子集

思路：回溯法，首先要将问题抽象成树形结构。注意，组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！

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

    public List<List<Integer>> subsets(int[] nums) {
        backtracking(nums, 0);
        return res;
    }

    private void backtracking(int[] nums, int start) {
        //「遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合」。
        res.add(new ArrayList<>(path));
        for (int i = start; i < nums.length; i++) {
            path.add(nums[i]);
            backtracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

---

90. 子集II

题目链接：90. 子集 II

思路：与上一题思路相同，但是要考虑去重的问题。注意，这里是要在同一个树层上进行去重，而不是在同一个树枝上进行去重。（注意去重需要先对集合排序）

从图中可以看出，同一树层上重复取2 就要过滤掉，同一树枝上就可以重复取2，因为同一树枝上元素的集合才是唯一子集！

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

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        // 先排序，让相同的元素靠在一起
        Arrays.sort(nums);
        backtracking(nums, 0);
        return res;
    }

    private void backtracking(int[] nums, int start) {
        res.add(new ArrayList<>(path));
        for (int i = start; i < nums.length; i++) {
            // 跳过当前树层使用过的、相同的元素
            if (i > start && nums[i] == nums[i - 1]) {
                continue;
            }
            path.add(nums[i]);
            backtracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

---