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

LeetCode 93.复原IP地址

此题明显是一个分割问题，利用回溯模版即可解决。回溯的终止条件为字符串s正好能被完整分割为4段且下一次分割的位置在字符串末尾。

但在解题的过程中卡了很久，对照看了题解和自己的代码，思路是一致的，最后发现是我在判断数字合法的时候的条件是nums<255，导致没结果输出，改成nums<=255后，答案就正确了，这些小细节还是要仔细些才行。代码如下：

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<String> result = new ArrayList<>();
    LinkedList<String> path = new LinkedList<>();
    public List<String> restoreIpAddresses(String s) {
        if(s.length() > 12) return result;
        backtracking(s, 0);
        return result;
    }
    public void backtracking(String s, int start){
        // 字符串刚好分割为4段且下一次分割的位置在字符串尾部
        if(path.size() == 4 && start == s.length()){
            String res = path.get(0) + "." + path.get(1) + "." + path.get(2) + "." + path.get(3);
            result.add(res);
            return;
        }
        // 字符串分割超过4段或者少于4段
        if(path.size() == 4 || start == s.length()) return;
        for(int i=start; i<s.length(); i++){
            String s1 = s.substring(start, i+1);
            // 剪枝，分割的数字不合法
            if(!islegal(s1)) break;
            path.add(s1);
            backtracking(s, i+1);
            path.removeLast();
        }
    }
    public boolean islegal(String s) {
        if(s.length() > 3) return false;
        int nums = Integer.parseInt(s);
        // 含前导0的字符转换为整型再转为字符串，其值是不相等的，若相等则说明不含前导0
        if(s.equals(nums+ "") && nums <= 255) return true;
        return false;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

LeetCode 78.子集

简单题，找出数组的所有子集，代码如下：

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        result.add(new ArrayList(path));
        backtracking(nums, 0);
        return result;
    }
    public void backtracking(int[] nums, int start){
        if(path.size() != 0){
            result.add(new ArrayList(path));
        }
        for(int i= start; i< nums.length; i++){
            path.add(nums[i]);
            backtracking(nums, i+1);
            path.removeLast();
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)

LeetCode 90.子集II

本题是基于上题，难度稍微加大了些。首先对于数组中有重复元素，又要求结果中不包含重复子集的问题，一般需要先对数组进行排序；其次去重时，需要判断是树层去重，还是树枝去重。本题很明显是数层去重。代码如下：

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList path = new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        result.add(new ArrayList(path));
        backtracking(nums, 0);
        return result;
    }
    public void backtracking(int[] nums, int start){
        result.add(new ArrayList(path));
        for(int i=start; i< nums.length; i++){
            // 对同一树层的元素去重
            if(i > start && nums[i] == nums[i-1]) continue;
            path.add(nums[i]);
            backtracking(nums, i+1);
            path.removeLast();
        }
    }
}
//leetcode submit region end(Prohibit modification and deletion)