代码随想录Day24

题目列表

• 93.复原IP地址(LeetCode)
• 78.子集(LeetCode)
• 90.子集II(LeetCode)

解题过程

93.复原IP地址

题目描述

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
示例 1：
输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
示例 2：
输入：s = "0000"
输出：["0.0.0.0"]
示例 3：
输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

解题思路

与 分割回文串 相似，也是要切割字符串，且每个子串都要符合一定的要求。
不同点：
循环结束条件：
找正确ip这道题，一旦发现有一个分割不符合要求（以0开头的长度大于1的子串、不是数字、子串对应的数字大于255），那么不用再继续这层循环了（不用i++了），直接 break.
而分割回文串，有一个分割不符合要求，可以continue,因为将下一个字符划入子串后可能会出现回文串。
递归结束条件：
找正确ip：可以记录分割数，将字符串分割成四部分就可以结束了，在这里用加的分隔符（'.'）的数目表示，也就是当 pointNum == 3时，判断最后一个部分是否有效，有效则记录这个字符串并返回，无效则直接返回。
分割回文串：则是分割线一直移动到字符串末尾才算结束。

代码展示

class Solution {
    List<String> result = new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        StringBuilder sb = new StringBuilder(s);
        backtracking(sb, 0, 0);
        return result;
    }
    public void backtracking(StringBuilder sb, int pointNum, int start){
        if(pointNum == 3){
            if(isVaild(sb, start, sb.length() - 1)) {
                result.add(sb.toString());
            }
            return;
        }
        for(int i = start; i < sb.length(); i++){
            if(isVaild(sb, start, i)) {
                sb.insert(i + 1, '.');
                pointNum++;
                backtracking(sb, pointNum, i + 2);
                sb.deleteCharAt(i + 1);
                pointNum--;
            }else{
                break;
            }
        }
    }
    boolean isVaild(StringBuilder s, int start, int end) {
        if(start > end) {
            return false;
        }
       if(s.charAt(start) == '0' && end != start) {
            return false;
       }
       int num = 0;
       for(int i = start; i <= end; i++) {
            if(s.charAt(i) < '0' || s.charAt(i) > '9') {
                return false;
            }
            num = (s.charAt(i) - '0') +  num * 10;
            if(num > 255) {
                return false;
            }
       }
       return true;
    }
}

78.子集

题目描述

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
输入：nums = [0]
输出：[[],[0]]

提示：
1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的所有元素 互不相同

解题思路

与之前做的回溯题目不太相同，之前都是满足终止条件才收集一次结果，而求子集意味着每一次递归的path都是一个结果，并且子集包括空集。
递归终止条件也就是循环终止条件。

代码展示

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 start) {
        result.add(new ArrayList<>(path));

        for(int i = start; i < nums.length; i++) {
            path.add(nums[i]);
            backtracking(nums, i + 1);
            path.removeLast();
        }
    }
}

90.子集II

题目描述

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的 子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
输入：nums = [0]
输出：[[],[0]]

提示：
1 <= nums.length <= 10
-10 <= nums[i] <= 10

解题思路

这道题去重思路和之前 组合总和II 类似，要考虑同一层去重:
不同结果集里同一层次上相等的值不要再用，否则会得到重复的结果。去重方法：跳过这一个，继续看下一个。去重前提：数组先排序。

代码展示

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 start){
        result.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.removeLast();
        }
    }
}

参考资料

代码随想录