day24 代码随想录 | 复原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 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址 ，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

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

这个题和切割字符串相似，只不过判断条件不一样。而且我们切割中止都是切割到末尾就可以结束了。此外，从题目的要求可以看到 s的长度应该在4-12之间，小于或大于这个长度就不可能完成满足条件的ip地址

回溯三部曲

1. 回溯参数

字符串，startIndex，path, result

2. 递归中止条件，就是startIndex== len(s) 并且你的path的长度为4了

3. 单层搜索：

从startIndex 到 len(s)

判断是否符合ip要求

回溯模板

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

    def backtracking(self, s, startIndex, path, result):
        if startIndex == len(s) and len(path) == 4:
            result.append(".".join(path[:]))

        if len(path) > 4:
            return 

        for i in range(startIndex, min(startIndex+3, len(s)):
            if self.isValid(s, start, i+1):
                path.append(s[startIndex, i+1])
                self.backtracking(s, i+1, path, result)
                path.pop()
            else:
                continue


    def isValid(self, s, start, end):
        cut_s = s[start: end]
        if start > end:
            return False
        if cut_s[start] == "0" and len(cut_s) > 1:
            return False

        num = int(cut_s)
        if num < 0 or num > 255:
            return False

        return True

78.子集

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

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

示例 1：

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

子集问题和前面的组合、分割问题都不相同。但是仍然可以用回溯解决。组合问题和分割问题我们都是要的叶子节点，而子集问题是要获取所有的节点。

也是用回溯模板，但是我们一开始就可以收集结果了

中止条件就是如果startIndex走到最后了，就可以返回了

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

    def backtracking(self, nums, startIndex, path, result):

        result.append(path[:]) # 直接收集

        if startIndex >= len(nums):
            return nums

        for i in range(startIndex, len(nums)):
            path.append(nums[i])
            self.backtracking(nums, i+1, path, result)
            path.pop()
            

90 子集II

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

子集（幂集）。

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

示例 1：

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

这个题的核心还是去重，跟之前的组合去重一样，是同层有重复元素去重，纵向的可以重复。

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        path = []
        result = []
        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, nums):
            if i > startIndex and nums[i-1] == nums[i]:
                    continue

            path.append(nums[i])
            self.backtracking(nums, i+1, path, result)
            path.pop()