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

系列文章目录

代码随想录算法训练营第一天|数组理论基础，704. 二分查找，27. 移除元素
代码随想录算法训练营第二天|977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II
代码随想录算法训练营第三天|链表理论基础，203.移除链表元素，707.设计链表，206.反转链表
代码随想录算法训练营第四天|24. 两两交换链表中的节点，19.删除链表的倒数第N个节点，面试题 02.07. 链表相交，142.环形链表II，总结
代码随想录算法训练营第五天|哈希表理论基础，242.有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和
代码随想录算法训练营第六天|454.四数相加II，383. 赎金信，15. 三数之和，18. 四数之和，总结
代码随想录算法训练营第七天|344.反转字符串，541. 反转字符串II，卡码网：54.替换数字，151.翻转字符串里的单词，卡码网：55.右旋转字符串
代码随想录算法训练营第八天|28. 实现 strStr()，459.重复的子字符串，字符串总结，双指针回顾
代码随想录算法训练营第九天|理论基础，232.用栈实现队列，225. 用队列实现栈
代码随想录算法训练营第十天|20. 有效的括号，1047. 删除字符串中的所有相邻重复项，150. 逆波兰表达式求值
代码随想录算法训练营第十一天|239. 滑动窗口最大值，347.前 K 个高频元素，总结
代码随想录算法训练营第十二天|理论基础，递归遍历，迭代遍历，统一迭代
代码随想录算法训练营第十三天|层序遍历10，226.翻转二叉树，101.对称二叉树
代码随想录算法训练营第十四天|104.二叉树的最大深度，559.n叉树的最大深度，111.二叉树的最小深度，222.完全二叉树的节点个数
代码随想录算法训练营第十五天|110.平衡二叉树，257. 二叉树的所有路径，404.左叶子之和
代码随想录算法训练营第十六天|513.找树左下角的值，112. 路径总和，113.路径总和ii，106.从中序与后序遍历序列构造二叉树，105.从前序与中序遍历序列构造二叉树
代码随想录算法训练营第十七天|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
代码随想录算法训练营第十八天|530.二叉搜索树的最小绝对差，501.二叉搜索树中的众数，236. 二叉树的最近公共祖先
代码随想录算法训练营第十九天|235. 二叉搜索树的最近公共祖先，701.二叉搜索树中的插入操作，450.删除二叉搜索树中的节点
代码随想录算法训练营第二十天|669. 修剪二叉搜索树，108.将有序数组转换为二叉搜索树，538.把二叉搜索树转换为累加树，总结篇
代码随想录算法训练营第二十一天|回溯算法理论基础，77. 组合
代码随想录算法训练营第二十二天|216.组合总和III，17.电话号码的字母组合
代码随想录算法训练营第二十三天|39. 组合总和，40.组合总和II，131.分割回文串

---

93.复原IP地址

题目链接： 93.复原IP地址
题目内容： 有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是"0.011.255.245"、“192.168.1.312” 和 “[email protected]” 是 无效 IP 地址。给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
视频讲解： 回溯算法如何分割字符串并判断是合法IP？| LeetCode：93.复原IP地址

关键：加逗点，判断IP地址的有效性

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

    def backtracking(self,s,startindex,point_num,current,result):
        if point_num == 3:
            if self.is_valid(s,startindex,len(s)-1):
                current += s[startindex:]
                result.append(current)
            return
        
        for i in range(startindex,len(s)):
            if self.is_valid(s,startindex,i):
                sub=s[startindex: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:
            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

78.子集

题目链接： 78.子集
题目内容： 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
视频讲解： 回溯算法解决子集问题，树上节点都是目标集和！ | LeetCode：78.子集

关键：之前的组合问题的结果都是在叶子结点，而子集问题的结果在树上的所有节点

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        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()

90.子集II

题目链接： 90.子集II
题目内容： 给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
视频讲解： 回溯算法解决子集问题，如何去重？| LeetCode：90.子集II

class Solution:
    def subsetsWithDup(self, nums):
        result = []
        path = []
        used = [False] * len(nums)
        nums.sort()  # 去重需要排序
        self.backtracking(nums, 0, used, path, result)
        return result

    def backtracking(self, nums, startIndex, used, path, result):
        result.append(path[:])  # 收集子集
        for i in range(startIndex, len(nums)):
            # used[i - 1] == True，说明同一树枝 nums[i - 1] 使用过
            # used[i - 1] == False，说明同一树层 nums[i - 1] 使用过
            # 而我们要对同一树层使用过的元素进行跳过
            if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]:
                continue
            path.append(nums[i])
            used[i] = True
            self.backtracking(nums, i + 1, used, path, result)
            used[i] = False
            path.pop()