Day 28 代码随想录 子集

---

93. 复原 IP 地址

  题目链接: 93. 复原 IP 地址

 
 这题需要加一个pointNum作为记号，因为只分割三次。

进阶写法

class Solution:
    def __init__(self):
        self.result=[]
    def restoreIpAddresses(self, s: str) :
        #self.result.clear()
        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:]
                self.backtracking(s, i + 2, point_num + 1)  # 在填入.后，下一子串起始后移2位
                s = s[:i + 1] + s[i + 2:]  # 回溯
            else:
                # 若当前被截取的子串大于255或者大于三位数，直接结束本层循环
                break
    def is_valid(self,s,start,end):
        if start > end:
            return False
        if s[start]=='0' and start!=end:
            return False
        if not 0 <= int(s[start:end+1]) <= 255:
            return False
        else:
            return True

普通写法

  这个写法能够更好的理解，就是套回溯算法的模板。

class solution:
    def restoreIpAddresses(self, s: str):
        global res
        global path
        res=[]
        path=[]
        def backtracking(s,start_index):
            global res
            global path
            if start_index==len(s) and len(path)==4:
                res.append('.'.join(path))
                return
            for i in range(start_index,len(s)):
                if len(path)>3:
                    break
                temp=s[start_index:i+1]
                if (0 <=int(temp)<=255 and temp[0]!='0') or temp=='0':
                    path.append(temp)
                    backtracking(s,i+1)
                    path.pop()
        backtracking(s,0)
        return res

78. 子集

   题目链接：78. 子集

 

  这题就是在每个叶子节点收集结果，不需要判断条件，直接收集。

代码

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        global path
        global res
        path=[]
        res=[]
        self.backtracking(nums,0)
        return res
    def backtracking(self,nums,start_index):
        global path
        global res
        res.append(path[:])
        if start_index >=len(nums):
            return
        for i in range(start_index,len(nums)):
            path.append(nums[i])
            self.backtracking(nums,i+1)
            path.pop()

90. 子集 II

   题目链接：90. 子集 II

 
这里就是要剪枝，这个之前组合问题II不一样，因为剪枝条件不一样。这个是回溯的时候相等就剪枝。

 

代码

class Solution:
    def subsetsWithDup(self, nums) :
        res=[]
        path=[]
        used=[0]*len(nums)
        def backtracking(nums,start_index,used):
            nums.sort()
            res.append(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] and used[i-1]==0:
                    continue
                path.append(nums[i])
                used[i]==1
                backtracking(nums,i+1,used)
                used[i]==0
                path.pop()
        backtracking(nums,0,used)
        return res