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

【参考链接】

93. 复原 IP 地址

【注意】

1.切割问题就可以使用回溯搜索法把所有可能性搜出来。

2.startIndex一定是需要的，因为不能重复分割，记录下一层递归分割的起始位置。

3.本题我们还需要一个变量pointNum，记录添加逗点的数量。

4.分割的段数作为终止条件。pointNum表示逗点数量（决定了树的深度），pointNum为3说明字符串分成了4段了。

5.循环中 [startIndex, i] 这个区间就是截取的子串，需要判断这个子串是否合法。如果合法就在字符串后面加上符号.表示已经分割。

6.左闭右闭。

【代码】

class Solution(object):
    def __init__(self):
        self.result = []
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        '''
        本质切割问题使用回溯搜索法，本题只能切割三次，所以纵向递归总共四层
        因为不能重复分割，所以需要start_index来记录下一层递归分割的起始位置
        添加变量point_num来记录逗号的数量[0,3]
        '''
        if len(s) > 12:
            return []
        #递归回溯
        self.backtracking(s,0,0)
        return self.result
    
    def backtracking(self,s,start_index,point_num):
        if point_num == 3:
            if self.is_valid(s, start_index, len(s)-1):#判断最后一个子串段是否满足
                self.result.append(s[:])
            return

        for i in range(start_index, len(s)):
            # [start_index, i]就是被截取的子串
            if self.is_valid(s, start_index, i):
                s = s[:i+1]+'.'+s[i+1:]
                # 在填入.后，下一子串起始后移2位
                self.backtracking(s,i+2,point_num+1)
                # 回溯
                s = s[:i+1]+s[i+2:]
            else:
                # 若当前被截取的子串大于255或者大于三位数，直接结束本层循环
                break

    def is_valid(self,s,start,end):
        if start > end:
            return False
         # 若数字是0开头，不合法
        if s[start] == '0' and start != end:
            return False
        if not 0 <= int(s[start:end+1]) <= 255:
            return False
        return True

78. 子集

【注意】

1.组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！

2.剩余集合为空的时候，就是叶子节点。就是startIndex已经大于数组的长度了，就终止了，因为没有元素可取了。

3.求取子集问题，不需要任何剪枝！因为子集就是要遍历整棵树。

【代码】

class Solution(object):
    def __init__(self):
        self.path = []
        self.paths = []

    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        self.backtracking(nums, 0)
        return self.paths

    def backtracking(self, nums, start_index):
        # 收集子集，要先于终止判断
        self.paths.append(self.path[:])
        # Base Case
        if start_index == len(nums):
            return

        # 单层递归逻辑
        for i in range(start_index, len(nums)):
            self.path.append(nums[i])
            self.backtracking(nums, i+1)
            self.path.pop()     # 回溯

90. 子集 II

【注意】

1.去重。

【代码】

 

class Solution(object):
    def __init__(self):
        self.path = []
        self.paths = []
    def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        #通过start_index进行去重
        #先对数组进行排序
        nums.sort()
        self.backtracking(nums,0)
        return self.paths
    
    def backtracking(self, nums, start_index):
        # 收集子集，要先于终止判断
        self.paths.append(self.path[:])
        if start_index == len(nums):
            return
        
        for i in range(start_index, len(nums)):
            #数层去重：
            if i > start_index and nums[i] == nums[i-1]:
                continue
            self.path.append(nums[i])
            self.backtracking(nums, i+1)
            self.path.pop()