Leetcode 刷题笔记1 回溯算法part03

leetcode 93 复原IP地址

本题的难点一是判断字符串是否有效，有很多小细节；二是对字符串串的切割

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        result = []
        self.backtracking(s, 0, 0, '', result)
        return result
    def backtracking(self, s, startIndex, point_num, current, result):
        if point_num == 3:
            if self.isVaild(s, startIndex, len(s) - 1):
                current += s[startIndex:]
                result.append(current)
            return 
        for i in range(startIndex, len(s)):
            if self.isVaild(s, startIndex, i):
                sub = s[startIndex: i + 1]
                self.backtracking(s, i + 1, point_num + 1, current + sub + '.', result)
            else:
                break
    def isVaild(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:
            return False
        num = 0
        for i in range(start, end + 1):
            if not s[i].isdigit():
                return False
            num = num * 10 + int(s[i])
            if num > 255:
                return False
        return True

leetcode 78 子集

本题比较简单，需要注意的是终止条件的判断

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

leetcode 90 子集||
结合题目组合总和秒了

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        result = []
        nums.sort()
        self.backtracking(nums, 0, [], result)
        return result
    def backtracking(self, nums, startIndex, path, result): 
        result.append(path[:])
        if startIndex > len(nums):
            return
        for i in range(startIndex, len(nums)):
            if i > startIndex and nums[i] == nums[i - 1]:
                continue
            path.append(nums[i])
            self.backtracking(nums, i + 1, path, result)
            path.pop()