代码随想录算法day21 | 回溯算法part03 | 93.复原IP地址， 78.子集，90.子集II

93.复原IP地址

class Solution:
    def backtracking(self,s,startIndex,postnum,current,result):
        if postnum==3:
            if self.isvalid(s,startIndex,len(s)):
                current+=s[startIndex:]
                result.append(current)
        
        for i in range(startIndex+1,min(startIndex+4,len(s))):
            if self.isvalid(s,startIndex,i):
                cut=s[startIndex:i]
                self.backtracking(s,i,postnum+1,current+cut+'.',result)
            else:
                break

    def isvalid(self,s,startIndex,endIndex):
        string_s=s[startIndex:endIndex]
        if string_s[0]=='0' and len(string_s) > 1:
            return False
        if int(string_s)>255:
            return False
        return True

    def restoreIpAddresses(self, s: str) -> List[str]:
        result=[]
        self.backtracking(s,0,0,"",result)
        return result

78.子集

class Solution:
    def backtracking(self,nums,startIndex,path,result):
        if startIndex==len(nums):
            return
        for i in range(startIndex,len(nums)):
            path.append(nums[i])
            result.append(path[:])
            self.backtracking(nums,i+1,path,result)
            path.pop()


    def subsets(self, nums: List[int]) -> List[List[int]]:
        result=[]
        result.append([])
        if len(nums)==1:
            result.append([nums[0]])
            return result
        self.backtracking(nums,0,[],result)
        return result

90.子集II

class Solution:
    def backtracking(self, nums, startIndex, used, path, result):
        result.append(path[:])
        for i in range(startIndex, len(nums)):
            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)
            path.pop()
            used[i]=False
        return

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