代码随想录Day23 | Leetcode93 复原 IP 地址、Leetcode78 子集 | Leetcode90 子集II

上题

93. 复原 IP 地址 - 力扣（LeetCode）

78. 子集 - 力扣（LeetCode）

90. 子集 II - 力扣（LeetCode）

第一题

有效 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"]

思路

• 老一套的回溯，用res记录结果，当len(res) == 4且i恰好等于字符串长度len(s)时，就是满足条件的一个IP
• 每个IP的整数位在[0,255]之间且不能含有前导0，但是可以是单个0，所以可以得到判断条件：
  • s[i:j+1] <= 255
  • s[i] != 0 或者 i == j，i==j时不管是不是0都能直接取，如果是前导0后续的循环仍会判断首位是否是0

代码

class Solutio:
    """
    有效 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"]
    """

    def restoreIpAddresses(self, s):
        result = []
        res = []
        n = len(s)

        def dfs(i):
            d = len(res)
            if i == n and d == 4:
                # print(res)
                re = '.'.join(res)
                result.append(re)
                return

            if d > 4:
                return

            for j in range(i, min(i + 3, n)):
                if int(s[i:j + 1]) < 256 and (s[i] != '0' or i == j):
                    res.append(s[i:j + 1])
                    dfs(j + 1)
                    res.pop()

        dfs(0)
        return result


if __name__ == '__main__':
    test = Solutio()
    s = ['25525511135', '0000', '101023', '025514255']
    for i in s:
        print(test.restoreIpAddresses(i))

第二题

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的
子集
（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

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

示例 2：
输入：nums = [0]
输出：[[],[0]]

思路

全列举并且包含空集，那在每次进入递归函数时添加一次结果即可

代码

class Solution:
    """
    给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的
    子集
    （幂集）。
    解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

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

    示例 2：
    输入：nums = [0]
    输出：[[],[0]]
    """

    def subsets(self, nums):
        result = []
        res = []
        n = len(nums)

        def dfs(i):
            result.append(res.copy())
            if i == n:
                return

            for j in range(i, n):
                res.append(nums[j])
                dfs(j+1)
                res.pop()

        dfs(0)
        return result


if __name__ == '__main__':
    test = Solution()
    nums = [[1, 2, 3], [0]]
    for i in nums:
        print(test.subsets(i))

第三题

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

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

示例 2：
输入：nums = [0]
输出：[[],[0]]

思路

可能有相同的元素，只需要对列表排序然判断当前元素是否与上个元素相同，相同则跳过

代码

class Solution:
    """
    给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
    解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

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

    示例 2：
    输入：nums = [0]
    输出：[[],[0]]
    """

    def subsetsWithDup(self, nums):
        result = []
        res = []
        n = len(nums)

        def dfs(i):
            result.append(res.copy())
            if i == n:
                return

            for j in range(i, n):
                if j > i and nums[j] == nums[j - 1]:
                    continue
                res.append(nums[j])
                dfs(j + 1)
                res.pop()

        nums.sort()
        dfs(0)
        return result
    

if __name__ == '__main__':
    test = Solution()
    nums = [[1, 2, 2], [0]]
    for i in nums:
        print(test.subsetsWithDup(i))

总结

回溯的套路已经深记脑子。。。。。。