代码随想录算法训练营Day 28| 回溯算法Part 04 | 93.复原IP地址、78.子集 、90.子集II

代码随想录算法训练营Day 28| 回溯算法Part 04 | 93.复原IP地址、78.子集 、90.子集II

---

今天的题目好简单！

---

93.复原IP地址

题目链接

类似分割回文串

一、回溯

class Solution(object):
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        result = []
        self.backtracking(s,[],result,0)
        return result
    def backtracking(self,s,path,result,startindex):
        if startindex == len(s) and len(path)==4:
            result.append(".".join(path[:])) 
            return
        if len(path)>4:
            return
        for i in range(startindex,len(s)):
            if self.isValid(s,startindex,i):
                path.append(s[startindex:i+1])
                self.backtracking(s,path,result,i+1)
                path.pop()
    def isValid(self,s,start,end):
        if  end - start > 2 or (s[start]=='0'and start != end):
            return False
        num =int(s[start:end+1]) 
        if num >255:
            return False
        return True

---

78.子集

题目链接

如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！

其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。

那么既然是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！

组合问题+result.append地方换一下

一、回溯

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        result = []
        self.backtracking(nums,[],result,0)
        result.append([]) #在判断后result.append
        return result

    def backtracking(self,nums,path,result,startindex):
        if startindex == len(nums):
            return 
        for i in range(startindex,len(nums)):
            path.append(nums[i])
            result.append(path[:]) # 或者在判断终止之前加入，就可以不在最后再append[]
            self.backtracking(nums,path,result,i+1)
            path.pop()
        

---

90.子集II

题目链接

40.组合总和II + 78.子集

一、利用递归的时候下一个startIndex是i+1而不是0去重

class Solution(object):
    def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        result=[]
        nums.sort()  # 去重需要排序！！！！
        self.backtracking(nums,[],result,0) 
        return result
    def backtracking(self,nums,path,result,startindex):
        result.append(path[:]) # 在判断终止之前加入，就可以不在最后再append[]
        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,result,i+1)
            path.pop()

二、利用set去重

class Solution:
    def subsetsWithDup(self, nums):
        result = []
        path = []
        nums.sort()  # 去重需要排序
        self.backtracking(nums, 0, path, result)
        return result

    def backtracking(self, nums, startIndex, path, result):
        result.append(path[:])  # 收集子集
        uset = set()
        for i in range(startIndex, len(nums)):
            if nums[i] in uset:
                continue
            uset.add(nums[i])
            path.append(nums[i])
            self.backtracking(nums, i + 1, path, result)
            path.pop()

三、利用used去重

class Solution:
    def subsetsWithDup(self, nums):
        result = []
        path = []
        used = [False] * len(nums)
        nums.sort()  # 去重需要排序
        self.backtracking(nums, 0, used, path, result)
        return result

    def backtracking(self, nums, startIndex, used, path, result):
        result.append(path[:])  # 收集子集
        for i in range(startIndex, len(nums)):
            # used[i - 1] == True，说明同一树枝 nums[i - 1] 使用过
            # used[i - 1] == False，说明同一树层 nums[i - 1] 使用过
            # 而我们要对同一树层使用过的元素进行跳过
            if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]:
                continue
            path.append(nums[i])
            used[i] = True
            self.backtracking(nums, i + 1, used, path, result)
            used[i] = False
            path.pop()