93.复原IP地址

思路： 这里startIndex为插入‘.’的位置，使用回溯法遍历所有插入的位置，直接在原始字符串上操作。要注意的是开闭区间的规定（这里我规定的是左闭右闭区间）。还要明确什么时候能return。

class Solution {
    private List<String> res=new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        StringBuilder sb=new StringBuilder(s);
        backtracking(sb,0,0);
        return res;


    }

    public void backtracking(StringBuilder sb,int stratIndex,int pointNums){
        if(stratIndex>=sb.length()) return;
        if(pointNums==3 && isValid(sb,stratIndex,sb.length()-1)){
            res.add(sb.toString());
            return;
        }  
        for(int i=stratIndex;i<sb.length();i++){
            if(isValid(sb,stratIndex,i)){//如果子串合法
                sb.insert(i+1,'.');
                backtracking(sb,i+2,pointNums+1);
                sb.deleteCharAt(i+1);
            }
        }
        return;
    }

    public boolean isValid(StringBuilder sb,int left,int right){
        if(sb.charAt(left)=='0' && right>left) return false;//判断前导0的情况
        int sum=0;
        for(int i=left;i<=right;i++){
            if(sb.charAt(i)<'0' && sb.charAt(i)>'9') return false;//判断不合法字符
            sum=sum*10+(sb.charAt(i)-'0');//计算总和
        }
        if(sum>=0 && sum<=255) return true;
        else{
            return false;
        }
    }
}

时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。
空间复杂度: O(n)

78.子集

子集和组合的区别：组合只需要获取叶子节点，而子集问题需要记录所有节点。
只需要在每次递归前将当前的子串写入结果中。

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

    public void backtracking(int[] nums,int startIndex){
        res.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);
        }
        return;
    }
}

时间复杂度: O(n * 2^n)
空间复杂度: O(n)

90.子集II

这道题与上一道不同点就是需要去重，去重的思想和之前组合的去重一样，需要横向剪枝，保留竖向的树枝。

class Solution {
    private List<Integer> path=new LinkedList<>();
    private List<List<Integer>> res=new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backtracking(nums,0);
        return res;
    }

    public void backtracking(int[] nums,int startIndex){
        res.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;
            path.add(nums[i]);
            backtracking(nums,i+1);
            path.remove(path.size()-1);
        }
        return;
    }
}

时间复杂度: O(n * 2^n)
空间复杂度: O(n)