day23|93.复原IP地址、78.子集、90.子集II

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"] 

问题分析：

 1、递归函数的参数和返回值

字符串s，分割线startIndex，逗点记录pointsum

2、终止条件

前提如果逗点数量为3个，后续第四个子串合法。因为如果前面三个不合法已经在单层搜索里排除了

3、单层搜索的逻辑

在for (int i=startIndex;i<s.length();i++)循环中 [startIndex, i] 这个区间就是截取的子串，需要判断这个子串是否合法。

如果合法就在字符串后面加上符号“.”再加上后面的字符串表示已经分割。

如果不合法就结束本层循环

递归调用时，下一层递归的startIndex要从i+2开始（因为需要在字符串中加入了分隔符.），同时记录分割符的数量pointnum 要 +1。

回溯的时候，就将刚刚加入的分隔符. 删掉，pointnum也要-1。

class Solution {

         List<String> result=new ArrayList<>();

    public List<String> restoreIpAddresses(String s) {
            backtracking(s,0,0);
            return result;
    }
    public void backtracking(String s,int startIndex,int pointsum){
        if (pointsum==3){//pointsum代表逗点和树的深度
            if (isValid(s,startIndex,s.length()-1)){//左闭右闭。判断第四个字符串是不是合法
                result.add(s);
            }
        }
        for (int i=startIndex;i<s.length();i++){
            if (isValid(s,startIndex,i)){//如果合法
                s=s.substring(0,i+1)+"."+s.substring(i+1);//substring是左闭右开
                pointsum++;
                backtracking(s,i+2,pointsum);//算上逗点的位置（i+1），新子串的start为i+2
                pointsum--;
                s=s.substring(0,i+1)+s.substring(i+2);//删除逗点，忽略i+1的位置
            }
            else break;//因为已经不是合法子串了，所以终止本树层向后面搜索
        }
    }
    public boolean isValid(String s,int start,int end){//左闭右闭
        if (start>end){
            return false;
        }
        if (s.charAt(start)=='0'&&start!=end){//0合法意味着子串里只有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;
    }
}

---

 78.子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]

输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 

示例 2：

输入：nums = [0]

输出：[[],[0]] 

问题分析：

1、递归函数的参数和返回值

数组、记录同一数组下标位startIndex 

2、终止条件

当startIndex>=nums.length终止，代表已经没有元素可取

3、单层搜索逻辑

每个节点都是子集，不需要剪枝

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);
            path.remove(path.size()-1);
        }
    }
}

---

 90.子集II 

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]

输出：[[],[1],[1,2],[1,2,2],[2],[2,2]] 

示例 2：

输入：nums = [0]

输出：[[],[0]] 

问题分析：

1、递归函数的参数和返回值

数组、记录同一数组下标位startIndex

2、终止条件

当startIndex>=nums.length终止，代表已经没有元素可取

3、单层搜索逻辑

需要去重

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]){//i>startIndex对于本层来说第一个元素已遍历完
                continue;
            }
            path.add(nums[i]);
            backtracking(nums,i+1);
            path.remove(path.size()-1);
        }
    }
}

注意：

排序问题和去重问题

一开始去重写成了 if (i>0&&nums[i]==nums[i-1])结果报错，问了大佬们

如果i>startIndex对于本层来说，已经不是第一个元素了