训练营第三十一天|LeetCode93、78、90

题目链接：93. 复原 IP 地址 - 力扣（LeetCode）

个人思路：对于切割IP地址，和上一题类似，但是我们最好不要使用切割线去描述，我们还是去使用指针来进行描述，这样会容易懂，主要的话要记住判断是否是有效值这个函数，然后如果判断成功给它加上一个点，然后递归下一层，下一层结束后回溯，再去递归另外一层

代码：

class Solution {
    List<String> res = new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
            backTracking(s,0,0);
            return res;
    }
    public void backTracking(String s , int startIndex,int pointSum){
        if(pointSum == 3){
            if(isValid(s,startIndex,s.length()-1)){
                res.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);
                pointSum++;
                backTracking(s,i+2,pointSum);
                pointSum--;
                s = s.substring(0,i+1)+s.substring(i+2);

            }else{
                break;
            }

        }

    }
    public 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;
    }
}

题目链接：78. 子集 - 力扣（LeetCode）

个人思路：子集问题和组合问题很像，基本不用什么操作空间，唯一需要注意的子集问题是每个节点都要添加到结果集里面去，组合问题是只添加叶子节点，所以我们要知道在哪个位置添加结果集

代码：

class Solution {
    LinkedList<Integer> path = new LinkedList<>();
    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));
        for(int i=startIndex;i<nums.length;i++){
            path.add(nums[i]);
            backTracking(nums,i+1);
            path.removeLast();
        }
        return;
    }
}

题目链接：90. 子集 II - 力扣（LeetCode）

个人思路：这是一道组合题目，题目自己之前也都写过，它是子集和去重的组合，我们对于去重要先想到，给数组排序，然后借用一个布尔类型的数组用来充当标识符，判断之前的元素是否使用过，如果没有这一个数组的话会出现这样的错误，例如[1,2,2]、[2,2]这两个数组是我们需要的，但是收集不到，因为这行代码会直接跳过这个

 if(i>0&&nums[i] == nums[i-1){
                continue;
}

还是和之前去重一样，如果第i个元素和前一个元素相同，那么就说明必定会有重复元素出现，但是重点是，这个第i个元素必须是排头，什么意思呢？就是这个第i个元素必须放在第一个位置。如果第i个元素和前一个元素相同，那么就是说，前一个元素已经把之前会出现的所有情况全都考虑进去了，因此第i个元素不能和前一个元素相同。

但是我们不能放弃符合条件，但是又是那种第i个元素和前一个元素相同的答案，因此我们要加入一条新的判断

 if(i>0&&nums[i] == nums[i-1]&&!used[i-1]==true){
                continue;
            }

用used来判断之前的元素是否使用过，如果使用过那么就说明这是一个新的答案，如果没使用过，那么就说明这个元素是排头，排头的元素不能和之前的元素相同，相同就会出现重复解

代码：

class Solution {
    LinkedList<Integer> path = new LinkedList<>();
    List<List<Integer>> res = new ArrayList<>();
    
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        boolean[] used = new boolean[nums.length];
        Arrays.fill(used,false);
        Arrays.sort(nums);
        backTracking(nums,0,used);
        
        return res;
    }   
    public void backTracking(int[] nums,int startIndex,boolean[] used){
        res.add(new ArrayList<>(path));
        for(int i =startIndex;i<nums.length;i++){
            if(i>0&&nums[i] == nums[i-1]&&!used[i-1]==true){
                continue;
            }
            path.add(nums[i]);
            used[i] = true;
            backTracking(nums,i+1,used);
            path.removeLast();
            used[i] = false;
        }
        return;
    }
}