算法工程师第二十一天（复原 IP 地址 子集 子集II ）

参考文献 代码随想录

一、复原 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"]

示例 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"]

提示：

• 1 <= s.length <= 20
• s 仅由数字组成

问题分析：寻找出合法的地址，首先要是合法的地址，第一个条件就是数字的第一个不能为零，第二个只能是数字，第三个只能有3个点，第四个每个数字地址不能大于255，然后回溯三部曲，第一步确定参数和返回值，没有返回值，参数有，start，pointsum，s，cur，star代表的是每一次切割的起始位置（就是切线要从start开始往后找），pointsum记录的点的数量，cur临时记录合法的地址，第二步确定终止条件，当pointsum == 3时，就结束循环，因为一个合法的IP地址就只用3个点，第三步，单层循环逻辑，首先判断它的字符串是否合法，那么我们该如何取到字字符串呢？答案是[start, i + 1]，为什么呢，因为star标记着下次循环切割线的开始位置，然后i回在每次递归中不断的移动，如果是合法字符串，则继续递归，否则跳出循环。

class Solution(object):
    def __init__(self):
        self.ans = []
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        self.backstrking(0, s, 0, "")
        return self.ans
    def backstrking(self,start, s, pointSum, cur): # pointSum 记录的的点的个数
        if pointSum == 3: # 因为合法地址就有3个点
            if self.vail(s, start, len(s) - 1):
                cur += s[start:]
                self.ans.append(cur)
            return
        for i in range(start, len(s)):
            if self.vail(s, start, i):
                sub = s[start: i + 1]
                self.backstrking(i + 1, s, pointSum + 1, cur + sub + ".")
            else:
                break
    def vail(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:
            return False
        for i in range(start, end + 1):
            if not s[i].isdigit():
                return False
        if int(s[start: end + 1]) > 255:
            return False
        return True

二、子集

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

子集

（幂集）。

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

示例 1：

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

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10
• nums 中的所有元素 互不相同

class Solution(object):
    def __init__(self):
        self.ans = []
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        if not nums:
            return self.ans
        self.backtriking(0, nums, [])
        return self.ans
    def backtriking(self, start, nums, li):
        self.ans.append(li[:])
        for i in range(start, len(nums)):
            self.backtriking(i + 1, nums, li + [nums[i]])

三、子集 II

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

子集

（幂集）。

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

示例 1：

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

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10

class Solution(object):
    def __init__(self):
        self.ans = []
    def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        if not nums:
            return self.ans
        nums.sort()  # 为什么要排序例如[2,5,6,6,7,8]如果遍历到第一个6的组合是不是已经包含了第二个6的组合
        self.backtriking(0, nums, [])
        return self.ans
    def backtriking(self, start, nums, li):
        self.ans.append(li[:])
        for i in range(start, len(nums)):
            if i > start and nums[i] == nums[i - 1]:
                continue
            self.backtriking(i + 1, nums, li + [nums[i]])