- 博客(166)
- 收藏
- 关注
RSS订阅原创 129.求根节点到叶节点的数字之和 python
为了解决这个问题，我们可以使用深度优先搜索（DFS）的方法来遍历二叉树，并在遍历过程中计算从根节点到每个叶节点所代表的数字。这种方法的时间复杂度是 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123。从根到叶子节点路径 4->9->5 代表数字 495。从根到叶子节点路径 4->9->1 代表数字 491。叶节点 是指没有子节点的节点。
2025-02-27 11:36:42
390
原创 128.最长连续序列 python
这种方法的时间复杂度为 O(n)，因为每个数字最多只会被访问两次（一次是作为序列起点，另一次是在后续序列的扩展中）。这种方法的基本思想是利用集合快速查找的特点，对于每个数字，检查它是否是一个序列的起点（即没有前驱数字），然后从这个起点开始向后计数直到序列结束。解释：最长数字连续序列是 [1, 2, 3, 4]。输入：nums = [0,3,7,2,5,8,4,6,0,1]输入：nums = [100,4,200,1,3,2]输入：nums = [1,0,1,2]
2025-02-25 12:01:08
796
原创 127.单词接龙 python
输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]解释：一个最短转换序列是 “hit” -> “hot” -> “dot” -> “dog” -> “cog”, 返回它的长度 5。时，立即返回当前的层级数加一，表示从。
2025-02-25 11:53:18
1159
原创 126.单词接龙Ⅱ python
输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]输出：[[“hit”,“hot”,“dot”,“dog”,“cog”],[“hit”,“hot”,“lot”,“log”,“cog”]]这有助于快速找到只相差一个字符的单词。
2025-02-24 09:32:04
980
原创 125.验证回文串 python
这种方法的时间复杂度为 O(n)，其中 n 是字符串的长度，因为我们只遍历了字符串两次（一次用于过滤和转换，另一次用于比较）。如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。给你一个字符串 s，如果它是 回文串 ，返回 true；解释：“amanaplanacanalpanama” 是回文串。解释：在移除非字母数字字符之后，s 是一个空字符串 “”。由于空字符串正着反着读都一样，所以是回文串。解释：“raceacar” 不是回文串。输入：s = " "
2025-02-24 09:21:32
912
原创 124.二叉树中的最大路径和 python
这种方法的时间复杂度为 O(n)，其中 n 是树中节点的数量，因为我们只需要遍历每个节点一次。空间复杂度取决于递归栈的深度，在最坏情况下是 O(n)（对于完全不平衡的树），但在平均情况下是 O(log n)（对于平衡树）。解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42。解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6。输入：root = [-10,9,20,null,null,15,7]路径和 是路径中各节点值的总和。
2025-02-21 09:44:26
792
原创 123.买卖股票的最佳时间Ⅲ python
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3。解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3。输入：prices = [3,3,5,0,0,3,1,4]将包含我们可以获得的最大利润。
2025-02-21 09:39:12
831
原创 122.买卖股票的最佳时机Ⅱ python
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。输入：prices = [7,1,5,3,6,4]返回 你能获得的 最大 利润。
2025-02-20 10:24:55
1398
原创 121.买卖股票的最佳时机 python
这种方法的时间复杂度为 O(n)，空间复杂度为 O(1)，非常高效。解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。同时，由于只使用了有限的额外变量，空间复杂度也非常低。给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。输入：prices = [7,6,4,3,1]输入：[7,1,5,3,6,4]
2025-02-20 10:18:32
821
原创 120.三角形最小路径和 python
给定一个三角形 triangle ，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]输出：11解释：如下面简图所示：23 46 5 74 1 8 3自顶向下的最小路径和为 11（即，2 + 3 +
2025-02-19 16:16:23
1055
原创 119.杨辉三角Ⅱ python
要解决这个问题，我们可以利用杨辉三角的性质：每一行的生成依赖于上一行的数据。为了达到 O(rowIndex) 的空间复杂度，我们只需要维护当前行的数据，并通过更新这一行的数据来生成下一行。给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。这个方法巧妙地利用了单个数组的空间，在不增加额外空间复杂度的情况下完成了任务。你可以优化你的算法到 O(rowIndex) 空间复杂度吗？输入: rowIndex = 3。输入: rowIndex = 1。输出: [1,3,3,1]
2025-02-19 16:11:01
348
原创 118.杨辉三角 python
这种方法的时间复杂度是 O(numRows^2)，因为我们需要生成 numRows 行，每行最多需要进行 numRows 次操作。空间复杂度也是 O(numRows^2)，因为我们需要存储所有的行数据。每一行的数字是基于上一行的数字计算得出的：每个数是它左上方和右上方的数之和。输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。
2025-02-18 16:13:28
434
原创 117.填充每个节点的下一个右侧节点指针Ⅱ python
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。与之前提到的完美二叉树不同，这里的二叉树可能不是完美的，即某些节点可能只有一个子节点或者没有子节点。指针，使其指向同一层中的下一个右侧节点。的属性，并且保证了每次都能正确地找到下一层的起点，从而防止了潜在的。输入：root = [1,2,3,4,5,null,7]输出：[1,#,2,3,#,4,5,7,#]你只能使用常量级额外空间。
2025-02-18 16:09:27
936
原创 116.填充每个节点的下一个右侧节点指针 python
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。由于题目要求只能使用常量级额外空间（不包括递归调用栈的空间），我们需要避免使用额外的数据结构如队列来进行层次遍历。这种方法利用了完美二叉树的结构特点，通过简单的递归实现了高效的连接操作。这种方法利用了完美二叉树的特性，并且只使用了递归调用栈作为额外空间，符合题目的进阶要求。输入：root = [1,2,3,4,5,6,7]输出：[1,#,2,3,#,4,5,6,7,#]首先定义二叉树节点的类。
2025-02-17 11:32:17
907
原创 115.不同的子序列 python
给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。这种方法的时间复杂度是 O(m * n)，空间复杂度也是 O(m * n)，其中。如下所示, 有 3 种可以从 s 中得到 “rabbit” 的方案。如下所示, 有 5 种可以从 s 中得到 “bag” 的方案。输入：s = “rabbbit”, t = “rabbit”输入：s = “babgbag”, t = “bag”我们可以定义一个二维的DP表。个字符的子序列出现的次数。
2025-02-17 11:25:26
489
原创 114.二叉树展开为链表 python
要将二叉树展开为一个单链表，并且该链表遵循先序遍历的顺序，我们可以采用原地算法来实现。这里我们将使用迭代的方法，因为它可以有效地利用常数空间复杂度（不包括输入和输出所需的空间）。这种方法利用栈来进行先序遍历，并在遍历过程中重构树结构，使其成为一个单链表。通过这种方式，我们能够在 O(n) 时间复杂度内完成任务，并且只使用 O(1) 额外空间（不计输入和输出所需的空间）。输出：[1,null,2,null,3,null,4,null,5,null,6]输入：root = [1,2,5,3,4,null,6]
2025-02-14 09:46:34
988
原创 113.路径总和Ⅱ python
具体来说，通过递归遍历树的每个节点，并在遍历过程中记录当前路径及其累积和，当到达叶子节点时检查累积和是否等于目标和。给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [1,2,3], targetSum = 5。输出：[[5,4,11,2],[5,8,4,5]]
2025-02-14 09:37:40
359
原创 112.路径总和 python
判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum。这种方法的时间复杂度是 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22。要判断二叉树中是否存在从根节点到叶子节点的路径，使得路径上所有节点值之和等于目标和。解释：由于树是空的，所以不存在根节点到叶子节点的路径。叶子节点 是指没有子节点的节点。
2025-02-13 15:17:03
699
原创 111.二叉树的最小深度 python
使用广度优先搜索可以确保我们找到的第一个叶子节点就是最短路径上的节点，因为BFS是逐层探索的。通过递归的方式也可以解决问题，但需要注意的是，如果只简单地取左右子树深度的最小值，可能会误判。对于这个问题，它特别有用，因为它能保证第一次遇到的叶子节点就是距离根节点最近的那个。输入：root = [2,null,3,null,4,null,5,null,6]输入：root = [3,9,20,null,null,15,7]最小深度是从根节点到最近叶子节点的最短路径上的节点数量。树中节点数的范围在 [0,
2025-02-13 15:12:02
995
原创 110.平衡二叉树 python
判断一棵二叉树是否为平衡二叉树，主要是检查对于树中的每一个节点，其左右子树的高度差不超过1。平衡二叉树的定义是：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个方法的时间复杂度接近 O(n)，其中 n 是树中节点的数量，因为每个节点只会被访问一次。输入：root = [1,2,2,3,3,null,null,4,4]输入：root = [3,9,20,null,null,15,7]树中的节点数在范围 [0, 5000] 内。输入：root = []
2025-02-13 15:05:30
993
原创 109.有序链表转化搜索二叉树 python
这个方法通过递归的方式有效地构建了一个平衡的二叉搜索树，并且保证了树的高度尽可能小，使得查找、插入等操作的时间复杂度保持在O(log n)级别。对于输入链表中的每个节点，该算法只访问一次，所以时间复杂度为O(n)，其中n是链表的长度。由于给定链表是有序的，因此可以利用这一特性来构建一个高度平衡的二叉搜索树。解释: 一个可能的答案是[0，-3,9，-10,null,5]，它表示所示的高度平衡的二叉搜索树。输入: head = [-10,-3,0,5,9]输出: [0,-3,9,-10,null,5]
2025-02-12 14:38:34
902
原创 108.将有序数组转换为二叉搜索树 python
这种方法保证了生成的二叉搜索树是高度平衡的，因为每次递归调用时都是基于当前子数组的中间值来分割数据集，从而确保左右子树的高度差不超过1。要将一个已经按升序排列的整数数组转换为一棵平衡二叉搜索树（BST），可以采用递归的方法。给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡二叉搜索树。解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。输入：nums = [-10,-3,0,5,9]输出：[0,-3,9,-10,null,5]输入：nums = [1,3]
2025-02-11 15:05:45
735
原创 107.二叉树的层序遍历 python
要实现二叉树的自底向上的层序遍历，我们可以采用标准的广度优先搜索（BFS）策略来遍历树的每一层，并在遍历完成后将结果反转，或者在遍历过程中使用栈数据结构来直接得到自底向上的顺序。这个方法利用了队列来进行层次遍历，并通过在结果列表的头部插入每层的遍历结果来达到自底向上的效果。这样，在遍历完所有节点后，我们就能得到所需的自底向上层序遍历的结果。输入：root = [3,9,20,null,null,15,7]输出：[[15,7],[9,20],[3]]输入：root = [1]输入：root = []
2025-02-11 14:32:44
186
原创 106.从中序与后序遍历序列构造二叉树 python
为了优化查找效率，可以使用哈希表记录每个值在中序数组中的索引，从而将查找操作的时间复杂度降低至O(1)，整体算法的时间复杂度可优化为O(n)。给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树。输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]输出：[3,9,20,null,null,15,7]
2025-02-10 14:17:36
695
原创 105.从前序与中序遍历序列构造二叉树 python
为了优化查找效率，可以使用哈希表记录每个值在中序数组中的索引，从而将查找操作的时间复杂度降低至O(1)，整体算法的时间复杂度可优化为O(n)。给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]输入: preorder = [-1], inorder = [-1]
2025-02-10 09:35:07
837
原创 104.二叉树的最大深度 python
这种方法的时间复杂度是O(n)，其中n是树中节点的数量，因为每个节点都被访问一次。空间复杂度最坏情况下是O(h)，这里h是树的高度，这是由于递归调用栈的深度所决定的。在完全不平衡的树的情况下（比如单边链表形式），空间复杂度会退化到O(n)；要计算二叉树的最大深度，可以使用递归的方法。这个方法的核心思想是：二叉树的最大深度等于其左子树和右子树的最大深度加1（根节点本身）。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。输入：root = [3,9,20,null,null,15,7]
2025-02-08 10:17:19
236
原创 103.二叉树的锯齿形层序遍历 python
为了实现二叉树的锯齿形层序遍历，我们可以使用广度优先搜索（BFS）的方法。具体来说，我们可以通过一个队列来逐层访问节点，并根据当前层次决定是从左到右还是从右到左添加节点值。此方法的时间复杂度为O(n)，其中n是树中节点的数量，因为每个节点都会被访问一次。给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。输入：root = [3,9,20,null,null,15,7]输出：[[3],[20,9],[15,7]]
2025-02-08 09:24:20
299
原创 102.二叉树的层序遍历 python
这种方法可以有效地完成二叉树的层序遍历，并且时间复杂度为 O(n)，其中 n 是树中节点的数量，因为每个节点都会被访问一次。空间复杂度主要取决于队列的大小，在最坏的情况下（完全平衡的二叉树），队列中最多会包含 N/2 个节点，因此空间复杂度为 O(n)。为了实现二叉树的层序遍历（广度优先搜索），我们可以使用队列数据结构来帮助我们逐层访问每个节点。输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]输入：root = [1]输入：root = []
2025-02-07 10:19:32
787
原创 101.对称二叉树 python
具体来说，对于每一层我们需要比较两个节点，并且这两个节点的子节点也需要满足镜像对称的关系。递归方法更加直观，而迭代方法则避免了潜在的栈溢出问题，尤其适用于深层嵌套的树结构。要检查一个二叉树是否轴对称，可以通过递归或迭代的方法来解决。我们可以将两个需要比较的节点同时入队，然后逐个出队进行比较。输入：root = [1,2,2,null,3,null,3]给你一个二叉树的根节点 root ， 检查它是否轴对称。输入：root = [1,2,2,3,4,4,3]进阶：你可以运用递归和迭代两种方法解决这个问题吗？
2025-02-07 10:01:21
984
原创 100.相同的树 python
具体来说，我们可以通过比较两棵树的根节点值以及它们各自的左子树和右子树来确定这两棵树是否相同。这种方法的时间复杂度为 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。输入：p = [1,2], q = [1,null,2]输入：p = [1,2,3], q = [1,2,3]输入：p = [1,2,1], q = [1,1,2]
2025-02-06 11:59:13
740
原创 99.恢复简单二叉树 python
通过Morris中序遍历的方法，我们可以在O(n)的时间复杂度和O(1)的空间复杂度下找到并交换两个被错误放置的节点。为了满足进阶要求，即只使用 O(1) 的额外空间（不包括递归栈的空间），我们可以采用Morris中序遍历的方法，这种方法不需要额外的栈或队列来辅助遍历，从而实现空间复杂度为O(1)的解法。给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。输入：root = [3,1,4,null,null,2]输出：[2,1,4,null,null,3]
2025-02-06 09:56:23
691
原创 98.验证二叉搜索树 python
要判断一棵二叉树是否为有效的二叉搜索树（BST），可以采用递归的方法，利用每个节点值必须处于一个特定的范围内这一性质。对于BST而言，根节点的值应该大于左子树中任何节点的值，并且小于右子树中任何节点的值。这种方法的时间复杂度为 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。函数来判断给定的二叉树是否是有效的二叉搜索树。解释：根节点的值是 5 ，但是右子节点的值是 4。节点的右子树只包含 大于 当前节点的数。
2025-02-05 15:43:21
834
原创 97.交错字符串 python
交错 是 s1 + t1 + s2 + t2 + s3 + t3 + …或者 t1 + s1 + t2 + s2 + t3 + s3 + …输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。输入：s1 = “”, s2 = “”, s3 = “”
2025-02-05 14:16:04
535
原创 96.不同的二叉搜索树 python
这个问题可以通过动态规划（Dynamic Programming, DP）来解决，因为它满足最优子结构性质：即问题的解可以由更小规模子问题的解构建而来。因为左子树和右子树都是 BSTs，并且它们的数量仅依赖于节点的数量，所以我们只需要知道对于任意数量的节点能形成多少种 BSTs 就可以了。给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？，内层循环尝试以每个节点作为根节点的情况，并根据左右子树的组合数更新当前节点数对应的 BST 数量。
2025-01-26 09:39:52
533
原创 95.不同的二叉搜索树Ⅱ python
为了生成所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同二叉搜索树（BST），我们可以使用递归和回溯的方法。输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树。可以按 任意顺序 返回答案。我们将这两个结果集合并，并将每一对左子树和右子树与当前根节点组合起来，形成一个完整的二叉搜索树。
2025-01-26 09:11:55
344
原创 94.二叉树的中序遍历 python
中序遍历（Inorder Traversal）是二叉树的一种遍历方式，其遍历顺序为：先访问左子树，然后访问根节点，最后访问右子树。对于每个子树来说，也是遵循相同的访问顺序。这种遍历方法特别适用于二叉搜索树（BST），因为在BST中进行中序遍历会按照升序访问节点。给定一个二叉树的根节点 root ，返回 它的 中序 遍历。输入：root = [1,null,2,3]树中节点数目在范围 [0, 100] 内。输入：root = [1]输入：root = []输出：[1,3,2]
2025-01-24 11:46:34
285
原创 93.复原IP地址 python
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]输入：s = “101023”
2025-01-24 09:25:10
586
原创 92.反转链表Ⅱ python
请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表。：反转完成后，将反转后的子链表重新连接回原链表中。具体来说，就是将反转部分的前驱节点指向新的头节点，并将反转部分的尾节点（即原来的头节点）指向反转部分之后的第一个节点。如果原头节点没有被包含在反转范围内，则直接返回哑节点的下一个节点；否则返回哑节点的下一个节点作为新头节点。输入：head = [1,2,3,4,5], left = 2, right = 4。个节点，这个节点将是反转部分的前驱节点。输出：[1,4,3,2,5]
2025-01-23 10:08:21
301
原创 91.解码方法 python
对于每个字符，我们需要考虑它是否可以单独作为一个有效的编码（即 “1” 到 “9”），以及它是否可以与前一个字符一起形成一个有效的两位数编码（即 “10” 到 “26”）。然而，在 解码 已编码的消息时，你意识到有许多不同的方式来解码，因为有些编码被包含在其它编码当中（“2” 和 “5” 与 “25”）。解释：它可以解码为 “BZ” (2 26), “VF” (22 6), 或者 “BBF” (2 2 6)。解释：“06” 无法映射到 “F” ，因为存在前导零（“6” 和 “06” 并不等价）。
2025-01-23 09:14:47
740
原创 90.子集Ⅱ python
的所有可能子集（幂集），我们需要考虑到重复元素会使得某些子集重复。为了避免在最终结果中出现重复的子集，我们可以在生成子集的过程中使用一种策略来避免重复。给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的 子集（幂集）。解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]输入：nums = [1,2,2]为了生成一个包含重复元素的数组。输入：nums = [0]输出：[[],[0]]
2025-01-22 10:29:55
383
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人