代码随想录算法训练营第二十四天|93.复原IP地址、78.子集、90.子集II

93.复原IP地址  

本期本来是很有难度的，不过 大家做完 分割回文串 之后，本题就容易很多了 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法如何分割字符串并判断是合法IP？| LeetCode：93.复原IP地址_哔哩哔哩_bilibili

我的问题：

1. pointSum错写在了单层递归的逻辑里，应该要在终止条件中。
2. 将"."简单地在加path的时候加入，导致最终有4个，然后删去最后一个；不需要path，直接在原始字符串s上添加"."，实现分割；在单层递归中通过加入"."实现路径的更新，回溯时就移除这个"."
3. 判断字符串s在左闭右开区间[start, end)所组成的数字是否合法写的有问题，没有排查所有可能情况

判断子串是否合法

最后就是在写一个判断段位是否是有效段位了。

主要考虑到如下三点：

• 段位以0为开头的数字不合法
• 段位里有非正整数字符不合法
• 段位如果大于255了不合法

class Solution {
    List<String> result = new ArrayList<>();

    public List<String> restoreIpAddresses(String s) {
        if (s.length() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result;
    }

    // startIndex: 搜索的起始位置， pointNum:添加逗点的数量
    public void backtracking(String s, int startIndex, int pointSum){
        if(pointSum == 3) {// 逗点数量为3时，分隔结束
            // 判断第四段⼦字符串是否合法，如果合法就放进result中
            if (isIPNum(s, startIndex, s.length())){
                result.add(s);
            }
            return;
        }

        for (int i = startIndex; i < s.length(); i++) {
            if (isIPNum(s,startIndex,i + 1)){
                s = s.substring(0, i + 1) + "." + s.substring(i + 1);    //在str的后⾯插⼊⼀个逗点
                pointSum++;
            }else {
                continue;
            }
            backtracking(s, i + 2, pointSum);// 插⼊逗点之后下⼀个⼦串的起始位置为i+2
            s = s.substring(0, i + 1) + s.substring(i + 2);// 回溯删掉逗点
            pointSum--;// 回溯
        }
    }

    // 判断字符串s在左闭右开区间[start, end)所组成的数字是否合法
    private boolean isIPNum(String s, int start, int end){
        String str = s.substring(start, end);
        if (start >= end) {
            return false;
        }
        if (s.charAt(start) == '0' && start != (end - 1)) { // 0开头的数字不合法
            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.子集  

子集问题，就是收集树形结构中，每一个节点的结果。 整体代码其实和 回溯模板都是差不多的。 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法解决子集问题，树上节点都是目标集和！ | LeetCode：78.子集_哔哩哔哩_bilibili

我的问题：收获结果result放在了for循环中；应该放在递归函数最开头，终止条件的上面（获取最后一个元素时，结果不会被省略），进入一层递归，就要把当前递归层的path放进结果集中

如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点，每个节点都是想要的结果，遍历每层递归，都把结果放进结果集！

其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。

那么既然是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！

子集问题很简单，其实这就是一道标准的模板题。

但是要清楚子集问题和组合问题、分割问题的的区别，子集是收集树形结构中树的所有节点的结果。

而组合问题、分割问题是收集树形结构中叶子节点的结果。

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

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

    public void backtracking(int[] nums, int startIndex){
        result.add(new ArrayList<>(path));// 收集子集，要放在终止添加的上面，否则会漏掉自己
        if(startIndex >= nums.length) return;//剩余集合为空的时候，就是叶子节点。 终止条件可以不加

        for (int i = startIndex; i < nums.length; i++) {
            path.add(nums[i]);// 子集收集元素
            backtracking(nums, i + 1);// 注意从i+1开始，元素不重复取
            path.remove(path.size() - 1);// 回溯
        }
    }
}

---

90.子集II 

大家之前做了 40.组合总和II 和 78.子集 ，本题就是这两道题目的结合，建议自己独立做一做，本题涉及的知识，之前都讲过，没有新内容。 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法解决子集问题，如何去重？| LeetCode：90.子集II_哔哩哔哩_bilibili

 记得去重问题要先排序数组

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

class Solution {
    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    List<Integer> path = new ArrayList<>();// 用来存放符合条件结果
    boolean[] used;

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        used = new boolean[nums.length];
        Arrays.sort(nums);// 去重需要排序
        backtracking(nums, 0);
        return result;
    }

    public void backtracking(int[] nums, int startIndex){
        result.add(new ArrayList<>(path));

        if (startIndex >= nums.length) return;

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

本题也可以不使用used数组来去重，因为递归的时候下一个startIndex是i+1而不是0。

如果要是全排列的话，每次要从0开始遍历，为了跳过已入栈的元素，需要使用used。

class Solution {
    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    List<Integer> path = new ArrayList<>();// 用来存放符合条件结果
    
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);// 去重需要排序
        backtracking(nums, 0);
        return result;
    }
    
    public void backtracking(int[] nums, int startIndex){
        result.add(new ArrayList<>(path));
        
        if (startIndex >= nums.length) return;

        for (int i = startIndex; i < nums.length; i++) {
            // 跳过当前树层使用过的、相同的元素
            if(i > startIndex && nums[i] == nums[i-1]) continue;// 注意这里使用i > startIndex
            path.add(nums[i]);
            backtracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}