代码随想录 回溯Ⅳ

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 中的任何数字。你可以按 任何 顺序返回答案。

思路：遍历＋回溯＋判断是否合法。本题字符串中的数字不可以重复使用，因此可以用startindex标记遍历的起点，在递归时让startindex变为i+1，表示下一个遍历起点在i的后面，其中，i为当前划分点，s[startindex:i + 1]这段字符串为当前划分的符合条件的字符串。用point_number来记录划分的次数，当point_number == 3,则意味着划分了四段字符串，判断最后一个字符串是否为合法字段（因为是判断合法才会划分前三段，所以最后一段合法则整个划分方式都合法），如果合法，则将其加入到结果集中，如果不合法则回溯。如果startindex遍历到最后point_number都不为3，也需要回溯。

Python：

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        ans = []
        self.backtracking(s,0,[],ans,0)
        return ans
    
    def backtracking(self, s:str, startindex:int, path:list, ans:list, pointnum:int):
        if startindex > len(s):
            return
        
        if pointnum == 3:
            if self.is_valid(s, startindex, len(s)-1):
                path.append(s[startindex:])  # 这里path.append,那么下面就要pop
                ans.append(".".join(path))
                path.pop()  # pop
            return
        
        for i in range(startindex, len(s)):
            if self.is_valid(s, startindex, i):
                path.append(s[startindex:i+1])
                pointnum += 1
                self.backtracking(s, i + 1, path, ans, pointnum)
                pointnum -= 1
                path.pop()
            else:
                continue




    def is_valid(self, s:str, start:int, end:int) -> bool:
        num = 0
        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
            
            num = num * 10 + int(s[i])
            if num > 255 or num < 0:
                return False
     
        return True

78. 子集

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

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

思路：循环加递归，将递归树上的每一个叶子都加入到结果集中

python：

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[:])  
        for i in range(startIndex, len(nums)):
            path.append(nums[i])
            self.backtracking(nums, i + 1, path, result)
            path.pop()

 

90. 子集 II

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

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

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

    
    def backtracking(self, nums, path, ans, startindex):
        ans.append(path[:])

        for i in range(startindex, len(nums)):
            if i > startindex and nums[i] == nums[i -1]:
                continue
            
            path.append(nums[i])
            self.backtracking(nums,path,ans,i + 1)  # It is worth noting that do not replace i to startindex
            path.pop()