【代码随想录】【回溯】day28：复原IP地址，子集问题-CSDN博客

本文链接：https://blog.csdn.net/weixin_45929355/article/details/136825779

文章介绍了如何使用Python解决复原IP地址问题，通过递归和回溯法处理字符串，判断子串是否符合IP地址规则，并讨论了子集问题的去重方法，利用排序和标记数组实现去重。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

复原IP地址

涉及到字符串和数字做比较的，全是坑

class Solution(object):
    def __init__(self):
        self.path=[]
        self.result=[]

    # 写一个函数判断分割结果是不是以0打头的
    def judge(self,p):
        if len(p)>1:
            for i in range(1,len(p)):
                # 如果不加int，一个是str,一个是int型
                if int(p[0])==0 and int(p[i])!=0:
                    return False

        return True
            
    def restoreIpAddresses(self, s):
        """
        :type s: str
        :rtype: List[str]
        """
        def backtracking(s, startindex):
            if startindex > len(s):
                return
            if len(self.path)>4:
                return
            if len(self.path) == 4 and startindex==len(s):
                f_s = ""
                for i in range(len(self.path)):
                    f_s += str(self.path[i]) + "."
                self.result.append(f_s[:-1])


            for i in range(startindex, len(s)):
                sub_s = s[startindex:i + 1]
                # 判断其中一个子串要在0-255之间并且不能0开头
                if int(sub_s)>=0 and int(sub_s) <= 255 and self.judge(sub_s) and len(sub_s)>=(int(len(s)/4)):
                    self.path.append(sub_s)
                    backtracking(s, i + 1)
                    self.path.pop()

        backtracking(s, 0)
        return self.result

子集问题

子集问题是每得到一个结果都是需要收取的，在每一次递归之后都要append。

def subsets(self, nums):
        result = []
        path = []
        self.backtracking(nums, 0, path, 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()

子集的去重

原始数组的元素有重复，但是子集不能重复，也就是同一树层上不能重复，但是树枝上可以重复

用used数组去重（在可以对原数组排序的情况下可以用）

！！！一定要排序

def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        def backtracking(nums,startindex):
            if startindex>len(nums):
                return 

            self.result.append(self.path[:])

            for i in range(startindex,len(nums)):
                if i>=1 and nums[i]==nums[i-1] and used[i-1]==False:
                    continue

                self.path.append(nums[i])
                used[i]=True
                backtracking(nums,i+1)
                self.path.pop()
                used[i]=False


        # 排序！！！
        nums=sorted(nums)
        used=[False]*len(nums)
        backtracking(nums,0)   
        return self.result