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

me_llamo

于 2024-07-26 14:02:43 发布

阅读量979

点赞数 11

文章标签：算法

本文链接：https://blog.csdn.net/weixin_45182267/article/details/140706797

版权

碎碎念：加油！！
参考：代码随想录

93.复原IP地址

题目链接

93.复原IP地址

思想

数字前面不能有0，不能大于255，不能出现非正整数
本题不仅要对字符串进行切割，还要进行合法性判断。
树形图：
在这里插入图片描述
".“有3个，而分割成的子串有4个，每次判断合法性都是对”."前面的子串进行检验，也就是说最后会有一个子串没有被检验，这需要最后处理一下。
用一个函数来封装判断合法性的操作，返回值是bool类型，参数是字符串的起始位置，字符串的终止位置。
这个函数的实现：

如果start>end，返回false
如果字符串以0为开头，则不合法
遍历字符串中的每一个字符，判断是否非数字字符，出现则返回false，如果数字大于255则也不合法。

回溯三部曲：

参数和返回值：参数有字符串s，startIndex（切割线），pointSum。
终止条件：如果pointSum==3，对最后一段进行合法性检验，合法的话就加入result。
单层搜索逻辑：for循环，i从startIndex开始，对切割的子串[startIndex,i]进行合法性判断，如果子串合法，在s中对应位置上加入"."，pointSum加一，向下一层递归(i+2)【之前给字符串加了一个点，要跳过】，删除之前插入的点，pointSum减一【这是回溯的过程】。

题解

class Solution:
    def isValid(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:
            return False
        num = 0
        for i in range(start, end + 1):
            if not s[i].isdigit():
                return False
            num = num * 10 + int(s[i])
            if num > 255:
                return False
        return True

    def backtracking(self, s, startIndex, pointSum,path,result):
        if pointSum == 3:
            if self.isValid(s, startIndex, len(s) - 1):
                path += s[startIndex:]
                result.append(path[:])
            return
        for i in range(startIndex, len(s)):
            if self.isValid(s, startIndex, i):
                sub = s[startIndex:i+1] # 左闭右开 切片
                self.backtracking(s, i+1, pointSum+1, path+sub+'.', result)  # 内含回溯
            else:
                break

            
    def restoreIpAddresses(self, s: str) -> List[str]:
        result = []
        self.backtracking(s, 0, 0, "", result)
        return result

class Solution:
    def isValid(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:
            return False
        num = 0
        for i in range(start, end + 1):
            if not s[i].isdigit():
                return False
            num = num * 10 + int(s[i])
            if num > 255:
                return False
        return True

    def backtracking(self, s, startIndex, pointSum,path,result):
        if pointSum == 3:
            if self.isValid(s, startIndex, len(s) - 1):
                path += s[startIndex:]
                result.append(path[:])
            return
        for i in range(startIndex, len(s)):
            if self.isValid(s, startIndex, i):
                sub = s[startIndex:i+1] # 左闭右开 切片
                self.backtracking(s, i+1, pointSum+1, path+sub+'.', result)  # 内含回溯
            else:
                break

            
    def restoreIpAddresses(self, s: str) -> List[str]:
        result = []
        self.backtracking(s, 0, 0, "", result)
        return result

反思

注意递归下一层的时候传的startIndex是i+2。

78.子集

题目链接

78.子集

思想

之前的题目收割结果都是在叶子节点时，但是本题每层递归都有结果需要放入结果集合。

树形图：
在这里插入图片描述
定义一个一维数组path，一个二维数组result。
一进入一个递归，就把当前的path放入result。
回溯三部曲：

参数和返回值：传入的参数有数组，startIndex，
终止条件：如果startIndex>=nums.size()，说明递归到了叶子节点，return；
单层搜索逻辑：for循环，i从startIndex开始，path收获单个元素，下层递归(i+1)，回溯，把元素弹出去。

题解

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path);
        if (startIndex >= nums.size()) {
            return;
        }
        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums, 0);
        return result;
    }
};

class Solution:
    def backtracking(self, nums, startIndex, path, result):
        result.append(path[:])
        if startIndex >= len(nums):
            return
        for i in range(startIndex, len(nums)):
            path.append(nums[i])
            self.backtracking(nums, i + 1, path, result)
            path.pop()
            

    def subsets(self, nums: List[int]) -> List[List[int]]:
        path = []
        result = []
        self.backtracking(nums, 0, path, result)
        return result

反思

注意子集问题和之前组合问题的区别。
注意收获结果的地方在一进来递归函数的地方，如果要把收获结果集的逻辑放在终止条件的下面，把最后一个元素放入path后的结果就被丢掉了。
本题甚至不需要终止条件，因为如果startIndex>nums的size以后，在for循环那里的逻辑也会被卡住退出，所以不会出现死循环。

90.子集II

题目链接

90.子集II

思想

本题是之前做过的40.组合总和II 和 78.子集的结合。
本题集合有重复元素，但本题又强调结果中不能又重复的结果，所以本题需要树层去重。
树形图：
在这里插入图片描述

在主函数中对nums进行排序，方便后续去重。
在进入递归函数后就进行结果收集。
回溯三部曲：

参数和返回值：nums startIndex used数组
终止条件：如果startIndex>=nums.size()，说明递归到了叶子节点，return；
单层搜索逻辑：for循环，i从startIndex开始。
如果当前遍历的元素和前一个元素相同（注意防止越界访问，i要>0），且used[i-1]=0 （当used[i-1]=1的时候，我们是在树枝的方向上，此时不能去重），此时continue。【关键的去重过程】
把nums[i]放入path，修改used，递归(i+1)，修改used，把nums[i]从path弹出（回溯过程）。

题解

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        result.push_back(path);
        if (startIndex >= nums.size()) {
            return;
        }
        for (int i = startIndex; i < nums.size(); i++) {
            if (i > startIndex && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, 0, used);
        return result;
    }
};

class Solution:
    def backtracking(self, nums, startIndex, path, result, used):
        result.append(path[:])
        if startIndex >= len(nums):
            return
        for i in range(startIndex, len(nums)):
            if i > startIndex and nums[i] == nums[i - 1] and not used[i - 1]:
                continue
            
            path.append(nums[i])
            used[i] = True
            self.backtracking(nums, i+1, path, result, used)
            used[i] = False
            path.pop()
        
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        path = []
        result = []
        used = [False] * len(nums)
        nums.sort()
        self.backtracking(nums, 0, path, result, used)
        return result