刷题11.8

1 复原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 中的任何数字。你可以按 任何 顺序返回答案

代码

class Solution {
    List<String> result =new ArrayList<>();
    List<String> path=new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        if (s.length() > 12) return result; 
        backtracking(s,0);
        return result;
    }
    public void backtracking(String s, int start){
        if(path.size()==3){
            if(isvaild(s,start,s.length()-1)){
                path.add(s.substring(start,s.length()));
                String str=listToStringTwo(path,'.');
                result.add(str);
                path.remove(path.size()-1);
            }
            return;
        }
        for(int i=start;i<s.length();i++){
            if(isvaild(s,start,i)){
                path.add(s.substring(start,i+1));
                backtracking(s,i+1);
                path.remove(path.size()-1);
            }
            else{
                break;
            }

        }
    }
    public boolean isvaild(String s,int start,int end){
        if(start>end) return false;
        String str=s.substring(start,end+1);
        if(s.charAt(start)=='0'&& start!=end)
            return false;
        if(0<=Integer.valueOf(str) && Integer.valueOf(str)<=255)
            return true;
        else
            return false;
    }
    public String listToStringTwo(List<String> list, char separator) {  
        StringBuilder sb = new StringBuilder();  
        for (int i = 0; i < list.size(); i++) {  
            if (i == list.size() - 1) {  
                sb.append(list.get(i));  
            } else {  
                sb.append(list.get(i));  
                sb.append(separator);  
            }  
        }  
        return sb.toString();  
    } 
}

总结

哎，总算写出来了。和昨天分割回文串思想一样，就是多了好多小细节。
我的java 是真的不行，list转成string这我都得百度下
s长度大于12，可以直接返回空。（我没想到，所以我int比大小还超过了int最大整数，报错了）

2 子集

题目

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

代码

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        result.add(new ArrayList<>(path));
        backtarcking(nums,0);
        return result;
    }
    public void backtarcking(int[] nums,int start){
        if(start>=nums.length) return;
        for(int i=start;i<nums.length;i++){
            path.add(nums[i]);
            result.add(new ArrayList<>(path));
            backtarcking(nums,i+1);
            path.remove(path.size()-1);
        }
        return;
    }
}

总结

鼓掌！！！自己写出来的，就是顺着代码运行，觉得这样可以实现。
参考代码是将result.add(path)放在了判断前面，我觉得这样理解起来更容易！而且还直接包含了空集。

3 子集II

题目

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

代码

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        backtarcking(nums,0);
        return result;
    }
    public void backtarcking(int[] nums,int start){
        result.add(new ArrayList<>(path));
        if(start>=nums.length) return;
        for(int i=start;i<nums.length;i++){
            if(i>start && nums[i]==nums[i-1]) continue;
            path.add(nums[i]);
            backtarcking(nums,i+1);
            path.remove(path.size()-1);
        }
        return;
    }
}

总结

和上一题求子集类似，只是多了去重这一步。而去重这一步之前也学过，哦耶！