代码随想录算法训练营Day 27 || 93.复原IP地址、78.子集、90.子集II-CSDN博客

本文链接：https://blog.csdn.net/m0_66462858/article/details/133925144

93.复原IP地址

力扣题目链接

给定一个只包含数字的字符串，复原它并返回所有可能的 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 地址。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

示例 2：

输入：s = "0000"
输出：["0.0.0.0"]

示例 3：

输入：s = "1111"
输出：["1.1.1.1"]

示例 4：

输入：s = "010010"
输出：["0.10.0.10","0.100.1.0"]

示例 5：

输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示：

0 <= s.length <= 3000
s 仅由数字组成

回溯（版本一）

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

    def backtracking(self, s, start_index, point_num, current, result):
        if point_num == 3:  # 逗点数量为3时，分隔结束
            if self.is_valid(s, start_index, len(s) - 1):  # 判断第四段子字符串是否合法
                current += s[start_index:]  # 添加最后一段子字符串
                result.append(current)
            return

        for i in range(start_index, len(s)):
            if self.is_valid(s, start_index, i):  # 判断 [start_index, i] 这个区间的子串是否合法
                sub = s[start_index:i + 1]
                self.backtracking(s, i + 1, point_num + 1, current + sub + '.', result)
            else:
                break

    def is_valid(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:  # 0开头的数字不合法
            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:  # 如果大于255了不合法
                return False
        return True

这段代码是一个解决IP地址恢复问题的Python实现。它的目标是把一个包含3个点分隔的字符串s（比如"1.1.1"）恢复成可能的IP地址列表。每个IP地址段都应该是三个0到255之间的数字，并且用点号分隔。每个IP地址可以有三个1到3个3位的数字，但是第一个和最后一个数字不能为0（除非它只有一个0）。

下面是代码的详细解释：

restoreIpAddresses是主函数，它创建一个空的结果列表，然后调用backtracking函数来尝试所有可能的IP地址组合。
backtracking是一个递归函数，它从给定的开始索引开始，尝试所有可能的子字符串。如果子字符串是一个有效的IP地址段，它将递归地尝试下一个子字符串，直到所有的IP地址段都被找到。如果找到的IP地址段是有效的，它将被添加到结果列表中。
is_valid是一个辅助函数，它检查一个给定的子字符串是否是一个有效的IP地址段。一个有效的IP地址段必须是三个0到255之间的数字，并且第一个和最后一个数字不能是0（除非只有一个0）。

请注意，这个代码对于非常长的字符串可能会运行得非常慢，因为它会尝试所有可能的子字符串。如果字符串s包含n个字符，那么这个函数将尝试大约2^n个不同的IP地址组合。因此，对于非常大的n，这个函数可能需要很长时间才能运行完毕。

78.子集

力扣题目链接(opens new window)

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

class Solution:
    def subsets(self, nums):
        result = []
        path = []
        self.backtracking(nums, 0, path, result)
        return result

    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()

这段代码是一个Python实现的回溯算法，用于生成数组的所有子集。代码中定义了一个名为Solution的类，其中包含两个方法：subsets和backtracking。

subsets方法是入口方法，它创建一个空的结果列表result和一个空的路径path，然后调用backtracking方法进行回溯。

backtracking方法是一个递归方法，用于生成所有可能的子集。它采用四个参数：nums是输入的数组，startIndex是开始索引，path是当前的子集，result是结果列表。

在backtracking方法中，首先将当前的子集path添加到结果列表result中（通过复制path列表实现）。然后，从startIndex开始遍历数组，将当前元素添加到path中，并递归调用backtracking方法，将索引加1，继续生成下一个子集。在递归返回之前，将刚刚添加的元素从path中弹出，以便尝试其他可能的组合。

这个算法的基本思想是遍历数组中的每个元素，将其添加到当前的子集中，并递归地生成包含该元素的所有子集。通过回溯，可以生成所有可能的子集。

90.子集II

力扣题目链接(opens new window)

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

说明：解集不能包含重复的子集。

示例:

输入: [1,2,2]
输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ]

class Solution:
    def subsetsWithDup(self, nums):
        result = []
        path = []
        used = [False] * len(nums)
        nums.sort()  # 去重需要排序
        self.backtracking(nums, 0, used, path, result)
        return result

    def backtracking(self, nums, startIndex, used, path, result):
        result.append(path[:])  # 收集子集
        for i in range(startIndex, len(nums)):
            # used[i - 1] == True，说明同一树枝 nums[i - 1] 使用过
            # used[i - 1] == False，说明同一树层 nums[i - 1] 使用过
            # 而我们要对同一树层使用过的元素进行跳过
            if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]:
                continue
            path.append(nums[i])
            used[i] = True
            self.backtracking(nums, i + 1, used, path, result)
            used[i] = False
            path.pop()

首先，定义了一个类Solution，在这个类中有两个方法：

subsetsWithDup(self, nums): 这是主方法，用于启动子集生成过程。它首先创建了两个空列表result和path，然后定义了一个布尔值列表used，所有元素初始化为False。然后对输入的nums进行排序，这样我们可以在回溯时跳过重复的元素。最后，它调用backtracking方法来生成子集。
backtracking(self, nums, startIndex, used, path, result): 这是一个递归方法，用于生成子集。它首先将当前的path添加到result中（通过复制path列表实现）。然后，从startIndex开始遍历数组，对于每个元素，如果它与前一个元素相同并且前一个元素没有被使用过，那么就跳过当前元素，以避免生成重复的子集。否则，将当前元素添加到path中，将该元素标记为已使用，然后递归地生成包含当前元素的子集。在递归返回之前，将刚刚添加的元素从path中弹出，将该元素标记为未使用，以便尝试其他可能的组合。