Leetcode刷题 Day 28 93. 复原 IP 地址 78. 子集 90. 子集 II

weixin_54199919

已于 2023-06-16 17:40:06 修改

阅读量170

点赞数

分类专栏： Leetcode刷题文章标签： leetcode tcp/ip 算法

于 2023-05-17 10:54:07 首次发布

本文链接：https://blog.csdn.net/weixin_54199919/article/details/130718563

版权

Leetcode刷题专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章介绍了如何使用Python的回溯算法来解决两个问题：一是从给定的字符串中恢复有效的IP地址，二是找到整数数组的所有子集。在IP地址恢复问题中，代码通过限制整数范围和避免前导零来确保有效性。在子集问题中，包括了无重复元素和可能有重复元素的情况，通过排序和回溯避免了子集的重复。

摘要由CSDN通过智能技术生成

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 中的任何数字。你可以按任何顺序返回答案。

class Solution: 
    def restoreIpAddresses(self, s: str) -> List[str]:
        global results, path
        results = []
        path = []
        self.backtracking(s,0)
        return results

    def backtracking(self,s,index):
        global results,path
        if index == len(s) and len(path)==4:
            results.append('.'.join(path)) # 在连接时需要中间间隔符号的话就在''中间写上对应的间隔符
            return
        for i in range(index,len(s)):
            if len(path)>3: break          # 剪枝
            temp = s[index:i+1]
            if (int(temp)<256 and int(temp)>0 and temp[0]!='0') or (temp=='0'):
                path.append(temp)
                self.backtracking(s,i+1)
                path.pop()

78 子集
给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按任意顺序返回解集。

class Solution:
    def __init__(self):
        self.path: List[int] = []
        self.paths: List[List[int]] = []

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

    def backtracking(self, nums: List[int], start_index: int) -> None:
        # 收集子集，要先于终止判断
        self.paths.append(self.path[:])
        # Base Case
        if start_index == len(nums):
            return

        # 单层递归逻辑
        for i in range(start_index, len(nums)):
            self.path.append(nums[i])
            self.backtracking(nums, i+1)
            self.path.pop()     # 回溯

90 子集 II
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。

class Solution:
    def __init__(self):
        self.paths = []
        self.path = []

    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        self.backtracking(nums, 0)
        return self.paths

    def backtracking(self, nums: List[int], start_index: int) -> None:
        # ps.空集合仍符合要求
        self.paths.append(self.path[:])
        # Base Case
        if start_index == len(nums):
            return
        
        # 单层递归逻辑
        for i in range(start_index, len(nums)):
            if i > start_index and nums[i] == nums[i-1]:
                # 当前后元素值相同时，跳入下一个循环，去重
                continue
            self.path.append(nums[i])
            self.backtracking(nums, i+1)
            self.path.pop()