代码随想录算法训练营day 28 |93.复原IP地址、78.子集、90.子集II

93.复原IP地址

代码随想录

思路：

分割字符串（判断回文子串）为基础，增加变量记录点的个数，终止条件为字符串内已经有3个点且最后一段也是有效的ip字段。改变字符串时直接在原字符串上操作。

判断是否为有效ip字段（字符串，起点，终点）：起点不能大于终点，不能是0开头的非单独字符串，每个字符都要在0~9内且组合起来的数字不能>255.

代码：

class Solution {
    List<String> res = new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        if(s.length() < 4 || s.length() > 12) return res;
        backtracking(s, 0, 0);
        return res;
    }

    private void backtracking(String s, int startindex, int pointnum){
        if(pointnum == 3 && isVaild(s, startindex, s.length() - 1)){
            res.add(s);
            return;
        }
        for(int i = startindex; i < s.length(); i++){
            if(isVaild(s, startindex, i)){
                s = s.substring(0, i + 1) + "." + s.substring(i + 1);
                pointnum++;
                backtracking(s, i + 2, pointnum);//加了逗号，所以下一个分割端起点为i+2
                pointnum--;
                s = s.substring(0, i + 1) + s.substring(i + 2);
            }else{
                break;
            }
        }
    }

    private boolean isVaild(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;//数字超过255也不行
        }
        return true;
    }
}

需要注意的点：

1、在最开始，字符串长度可以筛掉部分字符串。

2、判断字符串的范围为【startindex, i】，处理（分割）原字符串需要包含前面处理过的操作（从0开始）。

3、加了逗号之后下一个子段的起点要为i+2.

78.子集

代码随想录

思路：

不需要终止条件，每一个paths都会被加到res中。注意不能选之前选过的数字（设置一个startindex变量）。

代码：

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> paths = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        Arrays.sort(nums);
        backtracking(nums, 0);
        return res;
    }

    private void backtracking(int[] nums, int startindex){
        res.add(new ArrayList<>(paths));
        for(int i = startindex; i < nums.length; i++){
            paths.add(nums[i]);
            backtracking(nums, i + 1);
            paths.remove(paths.size() - 1);
        }
    }
}

需要注意的点：

90.子集II

代码随想录

思路：

和上一道子集思路一致，增加了同一层的去重（同一层选过的数字不能再选）。

代码：

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> paths = new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backtracking(nums, 0);
        return res;
    }

    private void backtracking(int[] nums, int startindex){
        res.add(new ArrayList<>(paths));
        for(int i = startindex; i < nums.length; i++){
            if(i > startindex && nums[i] == nums[i - 1]){
                continue;
            }else{
                paths.add(nums[i]);
                backtracking(nums, i + 1);
                paths.remove(paths.size() - 1);
            }
        }
    }
}

需要注意的点：

1、同一层不能选相同的数字。

2、为了方便去重（同一层不选相同数字），需要对数组先进行排序。