代码随想录算法训练营第二十八天| ● 93.复原IP地址 ● 78.子集 ● 90.子集II

题目链接:  ● 93.复原IP地址

题目链接/文章讲解：

视频讲解：回溯算法如何分割字符串并判断是合法IP？| LeetCode：93.复原IP地址_哔哩哔哩_bilibili

看完代码随想录之后的想法：

这道题使用回溯的方法解决；

我们用一个参数pointsum 控制递归;

当pointsum == 3 终止递归

然后for循环{

我们用startIndex 到 i 这个一个ip段；我们判断是否符合，如果不符合就break,如果符合就递归;

}

别忘了回溯；

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

 题目链接:  78.子集  

题目链接/文章讲解：代码随想录

视频讲解：回溯算法解决子集问题，树上节点都是目标集和！ | LeetCode：78.子集_哔哩哔哩_bilibili

看完代码随想录之后的想法：

这道题，我们需要注意result的位置就可以了;

class Solution {
    List<List<Integer>> result = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    void backTracking(int[] nums, int startIndex) {
        result.add(new LinkedList<>(path));
        if(startIndex == nums.length)
        return ;
        for(int i = startIndex; i < nums.length; i++) {
            path.add(nums[i]);
            
            backTracking(nums, i + 1);
            path.pollLast();
        }
    }
    public List<List<Integer>> subsets(int[] nums) {
        backTracking(nums, 0);
        return result;
    }
}

自己实现过程中遇到哪些困难 ：

在用暴力解法解决移除元素时，一开始没想到用size当作数组的长度，因此，一直为为最后一个数值是val苦恼，最后想到用-1代替最后的数值，也算是解决了问题；

 题目链接:90.子集II 

题目链接/文章讲解：代码随想录

视频讲解：回溯算法解决子集问题，如何去重？| LeetCode：90.子集II_哔哩哔哩_bilibili

我们需要去重，

在树中，有树层去重；有树枝去重；我们只需要树层去重，那么为了避免树枝去重，我们需要used[] 数组标记那个元素访问过；

然后按照回溯三部曲进行就可以了；

class Solution {
    List<List<Integer>> result = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    void backTracking(int[] nums, int startIndex, int[] used) {
        result.add(new LinkedList<>(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] == 0)
            continue;
            path.add(nums[i]);
            used[i] = 1;
            backTracking(nums, i + 1, used);
            path.pollLast();
            used[i] = 0;
        }
    }
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        int[] used = new int[nums.length];
        backTracking(nums, 0, used);
        return result;
    }
}