LeetCode 第二十四天 2024.8.10

1. ：复原IP地址
 题目链接: 93. 复原 IP 地址 - 力扣（LeetCode）
应用条件：回溯，递归

难点：

看到这道题不要被难住，没有思路是正常的，这道题的难点也是在于怎么去判断递归的终止条件，由于是四段，我们可以用startindex == len（s）和len(path) == 4来判断，同时要验证每次加的字符串是不是合规，我们也要另写一个isvaild函数判断字符串合规状态，别的就不用管了，一直递归就完事了。

个人错误：

思路：

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

    def backtracking(self,s,startindex,path,res):
        if startindex == len(s) and len(path) == 4:
            res.append(".".join(path))
            return
        if len(path) > 4:
            return
        for i in range(startindex,len(s)):
            if self.isvaild(s,startindex,i):
                sub = s[startindex:i+1]
                path.append(sub)
                self.backtracking(s,i+1,path,res)
                path.pop()
        

    
    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

2. ：子集
 题目链接: 78. 子集 - 力扣（LeetCode）
应用条件：回溯，递归

难点：

没什么难的，就是普通回溯

个人错误：

一开始在backtracking中res.append(cur[:])后加了return。导致每次只能放进去一个元素，注意什么时候要加return，什么时候不加

没有 return 的情况：
如果你不加 return，继续递归： 不加 return 时，递归调用会继续执行后面的循环和回溯操作。由于每次递归都会对 cur 进行不同的组合和回溯操作，最终所有可能的子集都会被添加到 res 中。

加 return 的情况：
加 return 的话，一旦递归到某个子集后，它会立即返回，停止当前路径的递归。这通常是在特定情况下使用的，例如当某个条件满足时提前终止递归。然而，在这个生成子集的场景中，递归调用不需要提前终止，因此 return 是不必要的。

思路：

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res =[]
        res.append([])
        if len(nums) == 0:
            return res
        self.backtracking(nums,[],res,0)
        return res

    def backtracking(self,nums,cur,res,startindex):
        if len(cur)>0:
            res.append(cur[:])
            
        for i in range(startindex,len(nums)):
            cur.append(nums[i])
            self.backtracking(nums,cur,res,i+1)
            cur.pop()

3. ：子集II
 题目链接: 90. 子集 II - 力扣（LeetCode）
应用条件：

难点：

和组合2一个思路，数组中有重复项但答案中不能有，需要在递归中有去重操作，判断这一项是否和前一项相等，使用时注意先对数组进行排序。

个人错误：

思路：

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        res=[]
        if len(nums) == 0:
            res.append([])
            return res
        nums.sort()
        self.backtracking(nums,0,[],res)
        return res

    def backtracking(self,nums,startindex,cur,res):
        res.append(cur[:])
        for i in range(startindex,len(nums)):
            if i > startindex and nums[i] == nums[i-1]:
                continue
            cur.append(nums[i])
            self.backtracking(nums,i+1,cur,res)
            cur.pop()