代码随想录算法训练营第二十四天|93.复原IP地址 78.子集 90.子集 II

93.复原IP地址

感觉这个题目和分割字符串很相似，我先试着写一写，难点在于它的分割线其实是固定四个的，而且不能在开头末尾，而且每个分完的要在0-255之间且不能有前导0，自己写出来了

class Solution:
    def __init__(self):
        self.result = []
        self.path = []
    def backtracking(self,s,startindex,num):
        if startindex==len(s) and num==4:
            self.result.append(".".join(self.path[:]))
            return self.result
        for i in range(startindex,len(s)):
            if int(s[startindex:i+1])<=255 and int(s[startindex:i+1])>=0:
                if int(s[startindex])!=0 or (int(s[startindex])==0 and len(s[startindex:i+1])==1):
                    self.path.append(s[startindex:i+1])
                    num+=1
                    self.backtracking(s,i+1,num)
                    self.path.pop()
                    num-=1
                
            
    def restoreIpAddresses(self, s: str) -> List[str]:
        self.backtracking(s,0,0)
        return self.result
        

我额外引入了一个记录切割次数的变量，然后判断是不是在0到255之间，并保证startindex是0的时候，这个被切分好的长度为1才能加入，这样就能得到正确的结果了。我在这里面没有判断非数字字符的问题，我看解析的代码是又判断的。我是习惯用列表去实现，但是我看解析不是，我懒得跟他们这样做了。

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

    def backtracking(self, s, start_index, point_num, current, result):
        if point_num == 3:  # 逗点数量为3时，分隔结束
            if self.is_valid(s, start_index, len(s) - 1):  # 判断第四段子字符串是否合法
                current += s[start_index:]  # 添加最后一段子字符串
                result.append(current)
            return

        for i in range(start_index, len(s)):
            if self.is_valid(s, start_index, i):  # 判断 [start_index, i] 这个区间的子串是否合法
                sub = s[start_index:i + 1]
                self.backtracking(s, i + 1, point_num + 1, current + sub + '.', result)
            else:
                break

    def is_valid(self, s, start, end):
        if start > end:
            return False
        if s[start] == '0' and start != end:  # 0开头的数字不合法
            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:  # 如果大于255了不合法
                return False
        return True

这样的话就需要在最后加入最后一段的话，还要在判断是不是满足数的要求

78.子集

因为数组中的元素本身互不相同，因此直接像组合一样不就可以了吗

class Solution:
    def __init__(self):
        self.result = []#初始化就把空集加上
        self.path = []
    def backtracking(self,nums,startindex):
        self.result.append(self.path[:])
        for i in range(startindex,len(nums)):
            self.path.append(nums[i])
            self.backtracking(nums,i+1)
            self.path.pop()
    def subsets(self, nums: List[int]) -> List[List[int]]:
        self.backtracking(nums,0)
        return self.result
        

90.子集 II

这个就是有重复的了，所以需要在搜索的时候同层不要重复，同一数枝可以重复

class Solution:
    def __init__(self):
        self.result = []#初始化就把空集加上
        self.path = []
    def backtracking(self,nums,startindex):
        self.result.append(self.path[:])
        for i in range(startindex,len(nums)):
            if i>startindex and nums[i]==nums[i-1]:
                continue
            else:
                self.path.append(nums[i])
                self.backtracking(nums,i+1)
                self.path.pop()
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        self.backtracking(sorted(nums),0)
        return self.result

做完组合再做这个很顺手