代码随想录算法训练营第28天 | 93.复原IP地址 + 78.子集 + 90.子集II

今日任务

目录

93.复原IP地址 - Medium

78.子集 - Medium

90.子集II - Medium

---

93.复原IP地址 - Medium

题目链接：力扣-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]:
        result = []
        path = []

        def backtracking(s, startIndex):
            if startIndex >= len(s) and len(path) == 4:
                result.append('.'.join(path))
                return           

            for i in range(startIndex, len(s)):
                temp = s[startIndex:i+1]
                if len(temp) > 1 and temp[0] == '0':
                    continue
                elif int(temp) > 255:
                    continue
                else:
                    path.append(temp)
                    backtracking(s, i+1)
                    path.pop()
        
        backtracking(s, 0)
        return result

78.子集 - Medium

题目链接：力扣-78. 子集

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

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

提示：子集也是一种组合问题，它的集合是无序的，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始；遍历树的时候，把所有节点都记录下来，就是要求的子集集合。

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

90.子集II - Medium

题目链接：力扣-90. 子集 II

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

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

提示：子集问题，结合去重

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