代码随想录算法训练营第28天 | 93、78、90

最新推荐文章于 2025-12-04 16:02:12 发布

原创最新推荐文章于 2025-12-04 16:02:12 发布 · 43 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #java #开发语言

文章介绍了如何通过回溯算法解决恢复有效IP地址及生成整数数组子集的问题。解法涉及字符串操作、递归以及剪枝策略，对于IP地址问题，关键在于判断和插入点号，而对于子集问题，重点是处理重复元素时的去重策略。

93.复原IP地址

题目描述

有效 IP 地址正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
例如：“0.1.2.201” 和 “192.168.1.1” 是有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你不能重新排序或删除 s 中的任何数字。你可以按任何顺序返回答案。
示例1：
输入： $s = "25525511135"$
输出： $["255.255.11.135", "255.255.111.35"]$
示例2：
输入： $s = "0000"$
输出： $["0.0.0.0"]$
示例3：
输入： $s = "101023"$
输出： $["1.0.10.23", "1.0.102.3", "10.1.0.23", "10.10.2.3", "101.0.2.3"]$

思路

本题的难点可以拆解为几个部分：
1、回溯分割
2、记录分割过程中的结果，对字符串相关的操作
3、判断分割结果是否合法
4、剪枝操作
首先是回溯分割的部分，不能重复分割，所以要在递归中的循环条件中每次使用startindex。同时，递归跳出的条件可以设置为分割已经进行到了最后一段，那么就是分割结束了，因为只需要切三刀就可以有四段，那么只需判断第四段是否合法。
对分割过程的记录过程需要对字符串进行操作，添加或去掉点，同时，这个点也需要记录次数来判断此时分割进行的进度。
判断分割结果是否合法可以独立设置一个方法来进行，在其中要对每一个分段的字符串进行判断，是否符合题目中的规定。
剪枝的操作主要发生在判断合法的时候，当一个字段并不合法后，之后的结果如何并不影响其最终不合法的结果，所以可以提前结束。

题解1

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

题解2

class Solution {
    List<String> res = new ArrayList<>();
    StringBuilder stringBuilder = new StringBuilder();
    public List<String> restoreIpAddresses(String s) {
        helper(s,0,0);
        return res;
    }
    public void helper(String s,int start,int number){
        if(start == s.length() && number == 4){
            res.add(stringBuilder.toString());
            return ;
        }
        if(start == s.length() || number == 4){
            return ;
        }
        for(int i = start;
        i < s.length() 
        && i-start < 3 
        && Integer.valueOf(s.substring(start,i+1)) >= 0
        && Integer.valueOf(s.substring(start,i+1)) <= 255;
        i++){
            if(i + 1 - start > 1 && s.charAt(start) -'0' == 0){
                continue;
            }
            stringBuilder.append(s.substring(start,i+1));
            if(number < 3){
                stringBuilder.append(".");
            }
            number++;
            helper(s,i+1,number);
            number--;
            stringBuilder.delete(start + number,i+number+2);
        }
    }
}

总结

解法1和解法2的区别主要在于对字符串的操作上，我更喜欢解法1，是比较容易想到的解法。但真的觉得这道题值得一个困难等级，值得反复看，思考量是真的足，CPU烧了。

78.子集

题目描述

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。你可以按任意顺序返回解集。
示例1：
输入： $n u m s = [1, 2, 3]$
输出： $[[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]$
示例2：
输入： $n u m s = [0]$
输出： $[[], [0]]$

思路

本题在看题时能感受到那种回溯的气息，但是又和之前的不一样。本题的特点是需要输出回溯树的所有节点，而非叶子节点，那么这种特点要如何在回溯中表达呢？
换个讲法，输出所有节点的更加通俗的理解就是，不加条件，不管是啥，全部保存然后输出，那么这样我们就能明白了，将之前放在递归函数的条件语句中的保存放在外面即可。

题解

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        helper(nums,0);
        return res;
    }
    public void helper(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]);
            helper(nums,i+1);
            path.removeLast();
        }
    }
}

总结

最初看到的时候可能想到的会是如何用条件来约束保存的列表，但想到最后发现好想也不需要条件来约束。那么只需要将其从条件语句中提出来。后面的条件语句中照常写跳出条件即可。

90.子集Ⅱ

题目描述

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。
示例1：
输入： $n u m s = [1, 2, 2]$
输出： $[[], [1], [1, 2], [1, 2, 2], [2], [2, 2]]$
示例2：
输入： $n u m s = [0]$
输出： $[[], [0]]$

思路

能看出本题与78相比的升级之处在于nums中包含重复元素但解集中不能包含重复的子集，那么考察的点自然就是去重。

题解

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

总结

去重的又一种应用方式，原理相同但具体的方法有所区别。