代码随想录算法训练营第二十八天【回溯】| 93, 78, 90

93. Restore IP Addresses

和palindrome那道题极度相似

模拟切割过程 = 组合问题里取数

字串合法性判断： [startIndex, i]

合法以后再加"."，在进行下一步递归回溯

class Solution(object):
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        result = []
        self.backtracking(s, 0, [], result)
        return result

    def backtracking(self, s, startIndex, path, result):
        if startIndex == len(s) and len(path) == 4:
            result.append('.'.join(path))
            return

        if len(path) > 4:  # 剪枝
            return

        for i in range(startIndex, min(startIndex+3,len(s))):
            if self.isValid(s, startIndex, i):
                sub = s[startIndex:i + 1]
                path.append(sub)
                self.backtracking(s, i+1, path, result)
                path.pop()

    def isValid(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:  # 0开头的数字不合法
            return False
        num = int(s[start:end+1])
        return 0 <= num <= 255
        




    

78. Subsets 

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        result = [[]]
        self.backtracking(0,[], nums, result)
        return result
 
    def backtracking(self, startIndex, path, nums, result):
        if len(path)==len(nums):
            return
        for i in range(startIndex, len(nums)):
            path.append(nums[i])
            result.append(path[:])
            self.backtracking(i+1, path, nums, result)
            path.pop()

90. Subsets II 

class Solution(object):
    def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
    
        used = [False] * len(nums)
        result = [[]]
        nums.sort()
        self.backtracking(nums,used,  0, [], result)
        return result
 
    def backtracking(self, nums, used, startIndex,  path, result):
        if len(path)==len(nums):
            return
        for i in range(startIndex, len(nums)):
            if i > startIndex and nums[i] == nums[i-1] and not used[-1]:
                continue
            if len(path)>len(nums):
                break
            
            path.append(nums[i])
            result.append(path[:])
            used[i] = True
            self.backtracking(nums, used,  i+1,path, result)
            path.pop()
            used[i] = False