算法刷题打卡024 | 回溯4

LeetCode 93 复原IP地址

题目链接：93. 复原 IP 地址 - 力扣（Leetcode）

 这一题和分割回文串是一个思路，只需要将判断字符串是否回文的条件换成判断字符串代表的数字是否在合适范围。前导零的判断代码应该还可以更精简一些，一开始只判断了大于0的数字是否含有前导零，忽略了0本身也可能包含多个零，这种IP也不是有效的。另外还要注意收集结果时，满足条件的IP得是4个整数，因此还要判断当前path中是否正好是4个有效的整数。

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

    def isValid(self, s):
        # if not s.isdigit():
        #     return False
        if int(s) > 255:
            return False  # 超出范围
        elif (int(s) > 0 and s[0] == '0') or (int(s) == 0 and len(s) > 1):
            return False  # 前导零  第二个条件是因为 '00'或'000'等
        else:
            return True

    def backtracking(self, s, idx, n):
        if idx >= n:
            if len(self.path) == 4:
                self.result.append('.'.join(self.path))
            return
        for i in range(idx, n):
            if self.isValid(s[idx: i+1]):
                self.path.append(s[idx: i+1])
            else:
                continue
            self.backtracking(s, i+1, n)
            self.path.pop()  # 回溯


    def restoreIpAddresses(self, s: str) -> List[str]:
        # if not s.isdigit():
        #     return []
        self.backtracking(s, 0, len(s))
        return self.result

LeetCode 78 子集

题目链接：78. 子集 - 力扣（Leetcode）

 按照讲解思路，这是一道经典的回溯题，和组合问题的区别在于，组合问题是在叶节点收集结果，而子集需要在树的每个节点收集结果。代码实现时有些纠结收集结果那行代码放的位置，调试了很久，一度放在了for循环里面，导致收集的结果会出现重复组合。但在正确放置result.append()那一行之后，依旧运行错误，找了好久才发现是path.append(nums[i])这里，写成了path.append(nums[idx])，导致每层遍历加入的都是同一个数，还是要注意细节啊。

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

        def backtracking(idx, n):         
            result.append(path[:])  # 加入结果
            if idx >= n:
                return 
            for i in range(idx, n):
                path.append(nums[i])  # 加入路径
                backtracking(i+1, n)  # 递归
                # result.append(path[:])  # 加入结果
                path.pop()  # 回溯
        
        backtracking(0, len(nums))
        return result

LeetCode 90 子集II

 题目链接：90. 子集 II - 力扣（Leetcode）

这道题和上一题子集的代码基本一样，由于数据有重复元素，需要在递归遍历前对数组排序，并在for循环中增加去重的逻辑： 

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        result, path = [], []

        def backtracking(startIndex, n):
            result.append(path[:])
            if startIndex >= n:
                return 
            for i in range(startIndex, n):
                if i > startIndex and nums[i] == nums[i-1]:
                    continue
                path.append(nums[i])
                backtracking(i+1, n)
                path.pop()
        
        backtracking(0, len(nums))
        return result