代码随想录算法训练营第二十七天 | Java |93.复原IP地址、78.子集、90.子集II【只有思路，还没吃透代码】-优快云博客

本文链接：https://blog.youkuaiyun.com/Arctic20/article/details/142864196

1 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.length <= 20
s 仅由数字组成

思路：先从简单处入手，判断地址小节是否有效，满足以下条件

（1）只有数字，无其他字符；

（2）小节数字小于或等于255，大于0；

（3）除0外，不能以‘0’开头。

其次是小节划分问题，因为是按序划分，与子集划分不同，只需要从前向后依次划分即可，当每轮划分结束后统一添加符合条件的划分结果。

注意：划分以添加句点为标志，会改变原字符串s的元素，添加句点后嵌套递归时要注意划分子集的起始位置。

Java实现

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

    public List<String> restoreIpAddresses(String s) {
        if(s.length()>12){
             return result;
        }
        backTrack(s,0,0);
        return result;
    }

    // 根据局点判断IP地址是否划分结束
    private void backTrack(String s, int startIndex, int pointNum){
        if(pointNum == 3){
            if(isValid(s,startIndex,s.length()-1)){
                result.add(s);
            }
            return ;
        }
        for(int i = startIndex;i<s.length();i++){
            if(isValid(s,startIndex,i)){
                s = s.substring(0,i+1)+"."+s.substring(i+1); // 添加句点
                pointNum++;
                backTrack(s,i+2,pointNum);
                pointNum--;
                s = s.substring(0,i+1) + s.substring(i+2);  // 回退句点
            }
            else{
                break;
            }
        }
    }

    private Boolean isValid(String s,int start, int end){
        if(start > end){
            return false;
        }
        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){
                return false;
            }
        }
        return true;
    }
}

2 78. 子集

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

提示：

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

思路：子集划分采用树的结构来帮助解题，遍历树的所有节点，以及路径上的节点组合，即得到全部子集。

注意：树的思路，同一层中已经分出去的节点，后续就不存在了，下一层遵循上层分配结果。

Java实现

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        subsetHelper(nums,0);
        return result;
    }

    private void subsetHelper(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]);
            subsetHelper(nums,i+1);
            path.removeLast();
        }
    }
}

3 90. 子集 II

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

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10

思路：不重复元素，需要对树进行剪枝，具体操作参考本题对应的代码随想录，我还没太学懂，就知道剪枝就可以了。

注意：吃头吃透吃透！

Java实现

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if(nums.length == 0){
            result.add(path);
            return result;
        }
        Arrays.sort(nums);  // 二叉树剪枝需要先排序
        used = new boolean[nums.length];
        subsetsWithDupHelper(nums,0);
        return result;
    }

    private void subsetsWithDupHelper(int[] nums, int startIndex){
        result.add(new ArrayList(path));
        if(startIndex >= nums.length){
            return ;
        }
        for(int i= startIndex;i<nums.length;i++){
            if(i>0 && nums[i]==nums[i-1] && !used[i-1]){
                continue;
            }
            path.add(nums[i]);
            used[i] = true;
            subsetsWithDupHelper(nums,i+1);
            path.removeLast();
            used[i] = false;
        }
    }
}