day23复原IP地址&子集&子集II（回溯三部曲详解版）

        今天题目中有回溯算法中的子集问题，也就是收集节点的值。

1.力扣93（复原IP地址）

        本题和昨天回文子串的题目类似，都是分割问题，不同的是我们需要对原字符串进行添加点和去点的回溯操作，并且结束条件也变为根据点的数量来判断是为符合终止条件。首先我们传入0为startIndex，然后利用for循环中的i遍历整个数组，如果遇到不符合的数字就break，因为如果继续遍历后面的元素也是不满足条件的。回溯三部曲：

• 递归参数：在中我们就提到切割问题类似组合问题。startIndex一定是需要的，因为不能重复分割，记录下一层递归分割的起始位置。本题我们还需要一个变量sum，记录添加逗点的数量。

    public void travleBacking(String s,int startIndex,int sum)

• 递归终止条件：本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件。sum表示逗点数量，sum为3说明字符串分成了4段了。然后验证一下第四段是否合法，如果合法就加入到结果集里

        if(sum == 3){
            if(isValid(s,startIndex,s.length()-1)){
                res.add(s);
            }   
            return;
        }

• 确定单层递归：在for循环中循环中 [startIndex, i] 这个区间就是截取的子串，需要判断这个子串是否合法。如果合法就在字符串后面加上符号.表示已经分割。如果不合法就结束本层循环

        for(int i=startIndex;i<s.length();i++){
            if(isValid(s,startIndex,i)){
                s =s.substring(0,i+1)+"."+s.substring(i+1);
                travleBacking(s,i+2,sum+1);
                s = s.substring(0, i + 1) + s.substring(i + 2);
            }else{
                break;
            }
        }

还有一个我们单独定义的一个方法

    public boolean isValid(String s,int left,int right){
        if(left>right){
            return false;
        }
        if(s.charAt(left) == '0'&&left!=right){
            return false;
        }
        int sum = 0;
        for(int i=left;i<=right;i++){
            if(s.charAt(i)<'0'||s.charAt(i)>'9'){
                return false;
            }
            sum = sum*10 + (s.charAt(i)-'0');
            if(sum>255){
                return false;
            }
        }
        return true;
    }

整体代码：

    List<String> res = new ArrayList();
    public List<String> restoreIpAddresses(String s) {
        travleBacking(s,0,0);
        return res;
    }
    public void travleBacking(String s,int startIndex,int sum) {
        if(sum == 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);
                travleBacking(s,i+2,sum+1);
                s = s.substring(0, i + 1) + s.substring(i + 2);
            }else{
                break;
            }
        }
    }
    public boolean isValid(String s,int left,int right){
        if(left>right){
            return false;
        }
        if(s.charAt(left) == '0'&&left!=right){
            return false;
        }
        int sum = 0;
        for(int i=left;i<=right;i++){
            if(s.charAt(i)<'0'||s.charAt(i)>'9'){
                return false;
            }
            sum = sum*10 + (s.charAt(i)-'0');
            if(sum>255){
                return false;
            }
        }
        return true;
    }

2.力扣78（子集）

         我们所要求的结果就为这棵树的节点值，所以我们在遍历的过程中把节点入结果集就好了。回溯三部曲：

• 递归函数参数：集合path收集元素，集合res存放结果集。

    public void backtracking(int[] nums,int startIndex) 

• 递归终止条件：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);
        }

整体代码：

    List<List<Integer>> res = new ArrayList();
    List<Integer> path = 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);
        }
    }

3.力扣90（子集II）

        本题和上题的区别就是我们需要处理树层重复的问题，昨天的题目中有这中去重的操作，我们直接用就可以了，所以我们只需要在for循环里添加去重的操作就可以了。下面是需要修改的地方：

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

 整体代码：

    List<List<Integer>> res = new ArrayList();
    List<Integer> path = new ArrayList();
    boolean[] used;
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        used = new boolean[nums.length];
        Arrays.fill(used,false);
        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>0&&nums[i]==nums[i-1]&&!used[i-1]){
                continue;
            }
            path.add(nums[i]);
            used[i]=true;
            backtracking(nums,i+1);
            used[i]=false;
            path.remove(path.size()-1);
        }
    }