代码随想录算法训练营 Day 21

less than 1 minute read

Published:

Q1. LeetCode 93

题目描述中可以同一个数字出现多次,所以开始索引不用加一。

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        res = []

        # 判断是否合法:1. 长度大于1时,首位数是否为0;2. 数字整体是否大于255;3. 其中是否含有非数字字符(本题中明确规定只含有数字,因此省略)
        def is_valid(substring):
            if len(substring) > 1 and substring[0] == '0':
                return False
            
            if int(substring) > 255:
                return False
            
            return True

        def backtracking(num_part, start, arr):
            if num_part == 4:
                # 整个字符参与划分,即没有剩下的部分
                if start == len(s):
                    res.append('.'.join(arr))
                return
            
            for i in range(start, len(s)):
                substring = s[start:i+1]
                if is_valid(substring):
                    arr.append(substring)
                    num_part += 1
                    backtracking(num_part, i + 1, arr)
                    num_part -= 1
                    arr.pop()
        
        backtracking(0, 0, [])

        return res

复杂度分析

时间复杂度:O($3^4$) 空间复杂度:O($n$)

Q2. LeetCode 78

题目要求返回的是集合,而集合是无序的,因此还是要起始位置不在0而是开始索引

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []

        def backtracking(start, arr):
            res.append(arr[:])
            
            for i in range(start, len(nums)):
                arr.append(nums[i])
                backtracking(i + 1, arr)
                arr.pop()
        
        backtracking(0, [])

        return res

复杂度分析

时间复杂度:O($n \times 2^n$) 空间复杂度:O($n$)

Q3. LeetCode 90

排序后利用索引去重。特殊情况:[2,2,3,3,2],相同元素初始位置可能没有相连

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        res = []

        nums.sort()
        def backtracking(start, arr):
            res.append(arr[:])

            for i in range(start, len(nums)):
                if i > start and nums[i] == nums[i - 1]:
                    continue
                    
                arr.append(nums[i])
                backtracking(i + 1, arr)
                arr.pop()
        
        backtracking(0, [])

        return res

复杂度分析

时间复杂度:O($n \times 2^n$) 空间复杂度:O($n$)