WhiteGray-CSDN博客

原创 297. 二叉树的序列化与反序列化

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。示例 1：输入：root = [1,2,3,null,null,4,5]输出：[1,2,3,null,null,4,5]示例 2：输入：root

2021-05-01 22:54:21 188

原创 1011. 在 D 天内送达包裹的能力

传送带上的包裹必须在 D 天内从一个港口运送到另一个港口。传送带上的第 i 个包裹的重量为 weights[i]。每一天，我们都会按给出重量的顺序往传送带上装载包裹。我们装载的重量不会超过船的最大运载重量。返回能在 D 天内将传送带上的所有包裹送达的船的最低运载能力。示例 1：输入：weights = [1,2,3,4,5,6,7,8,9,10], D = 5输出：15解释：船舶最低载重 15 就能够在 5 天内送达所有包裹，如下所示：第 1 天：1, 2, 3, 4, 5第 2 天：6,

2021-04-26 10:16:03 132

原创 897. 递增顺序搜索树

给你一棵二叉搜索树，请你按中序遍历将其重新排列为一棵递增顺序搜索树，使树中最左边的节点成为树的根节点，并且每个节点没有左子节点，只有一个右子节点。示例 1：输入：root = [5,3,6,2,4,null,8,1,null,null,null,7,9]输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]示例 2：输入：root = [5,1,7]输出：[1,null,5,null,7]提示：树中节点数的取值

2021-04-25 09:54:49 132

原创 377. 组合总和 Ⅳ

给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。题目数据保证答案符合 32 位整数范围。示例 1：输入：nums = [1,2,3], target = 4输出：7解释：所有可能的组合为：(1, 1, 1, 1)(1, 1, 2)(1, 2, 1)(1, 3)(2, 1, 1)(2, 2)(3, 1)请注意，顺序不同的序列被视作不同的组合。示例 2：输入：nums = [9]

2021-04-24 11:19:48 108

原创 363. 矩形区域不超过 K 的最大数值和

给你一个 m x n 的矩阵 matrix 和一个整数 k ，找出并返回矩阵内部矩形区域的不超过 k 的最大数值和。题目数据保证总会存在一个数值和不超过 k 的矩形区域。示例 1：输入：matrix = [[1,0,1],[0,-2,3]], k = 2输出：2解释：蓝色边框圈出来的矩形区域 [[0, 1], [-2, 3]] 的数值和是 2，且 2 是不超过 k 的最大数字（k = 2）。示例 2：输入：matrix = [[2,2,-1]], k = 3输出：3提示：m ==

2021-04-22 10:37:56 143

原创 91. 解码方法

一条包含字母 A-Z 的消息通过以下映射进行了编码：'A' -> 1'B' -> 2...'Z' -> 26要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为："AAJF" ，将消息分组为 (1 1 10 6)"KJF" ，将消息分组为 (11 10 6)注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。给你

2021-04-21 10:01:26 371

原创 213. 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。示例 1：输入：nums = [2,3,2]输出：3解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

2021-04-15 11:03:55 58

原创 783. 二叉搜索树节点最小距离

给你一个二叉搜索树的根节点 root ，返回树中任意两不同节点值之间的最小差值。注意：本题与 530：https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同示例 1：输入：root = [4,2,6,1,3]输出：1示例 2：输入：root = [1,0,48,null,null,12,49]输出：1提示：树中节点数目在范围 [2, 100] 内0 <= Node.val <

2021-04-13 09:45:39 80

原创 264. 丑数 II

给你一个整数 n ，请你找出并返回第 n 个丑数。丑数就是只包含质因数 2、3 和/或 5 的正整数。示例 1：输入：n = 10输出：12解释：[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。示例 2：输入：n = 1输出：1解释：1 通常被视为丑数。提示：1 <= n <= 1690解答下一个丑数必然由过去已经产生的丑数，分别乘以2，3，5中得到的最小值（去除已经出现过的数字）得到，因此可以使用三个指针

2021-04-11 10:37:08 81

原创 154. 寻找旋转排序数组中的最小值 II

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]]。给你一个可能存在重复元素值的数组

2021-04-09 10:29:50 109

原创 153. 寻找旋转排序数组中的最小值

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]若旋转 4 次，则可以得到 [0,1,2,4,5,6,7]注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。给你一个元素值互不相同的数组nu

2021-04-08 10:07:27 95

原创 81. 搜索旋转排序数组 II

已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

2021-04-07 10:01:32 94

原创 88. 合并两个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。示例 1：输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3输出：[1,2,2,3,5,6]示例 2：输入：nums1 = [1], m =

2021-04-05 11:06:35 88

原创 781. 森林中的兔子

森林中，每个兔子都有颜色。其中一些兔子（可能是全部）告诉你还有多少其他的兔子和自己有相同的颜色。我们将这些回答放在 answers 数组里。返回森林中兔子的最少数量。示例:输入: answers = [1, 1, 2]输出: 5解释:两只回答了 "1" 的兔子可能有相同的颜色，设为红色。之后回答了 "2" 的兔子不会是红色，否则他们的回答会相互矛盾。设回答了 "2" 的兔子为蓝色。此外，森林中还应有另外 2 只蓝色兔子的回答没有包含在数组中。因此森林中兔子的最少数量是 5: 3 只回答的

2021-04-04 10:14:55 109

原创 1143. 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的公共子序列是这两个字符串所共同拥有的子序列。示例 1：输入：text1 = "abcde", text2 = "ace"

2021-04-03 10:19:39 77

原创面试题 17.21. 直方图的水量

给定一个直方图(也称柱状图)，假设有人从上面源源不断地倒水，最后直方图能存多少水量?直方图的宽度为 1。上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的直方图，在这种情况下，可以接 6个单位的水（蓝色部分表示水）。感谢 Marcos 贡献此图。示例:输入: [0,1,0,2,1,0,1,3,2,1,2,1]输出: 6解答位置i处的水量由左右两侧最高处其中的较小值决定，因此可以使用双指针法，此外记录left指针左侧的最大值left_max，以及right指针右侧的最大

2021-04-02 10:50:28 90

原创 1006. 笨阶乘

通常，正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。相反，我们设计了一个笨阶乘 clumsy：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而，这些运算仍然使用通常的算术运算顺序：我们在任何

2021-04-01 10:05:04 72

原创 90. 子集 II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。示例 1：输入：nums = [1,2,2]输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]示例 2：输入：nums = [0]输出：[[],[0]]提示：1 <= nums.length <= 10-10 <= nums[i] <= 10解答递归+回溯class Sol

2021-03-31 10:24:57 152

原创 173. 二叉搜索树迭代器

实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。int next()将指针向右移动，然后返回指针处的数字。

2021-03-28 10:26:29 71

原创 61. 旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。示例 1：输入：head = [1,2,3,4,5], k = 2输出：[4,5,1,2,3]示例 2：输入：head = [0,1,2], k = 4输出：[2,0,1]提示：链表中节点的数目在范围 [0, 500] 内-100 <= Node.val <= 1000 <= k <= 2 * 10^9解答实际上就是将原链表的后k（对链表长度取模后）个元素接到前面去：cl

2021-03-27 11:00:34 74

原创 83. 删除排序链表中的重复元素

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素只出现一次。返回同样按升序排列的结果链表。示例 1：输入：head = [1,1,2]输出：[1,2]示例 2：输入：head = [1,1,2,3,3]输出：[1,2,3]提示：链表中节点数目在范围 [0, 300] 内-100 <= Node.val <= 100题目数据保证链表已经按升序排列解答与82. 删除排序链表中的重复元素 II的区别在于不要求把重复的节

2021-03-26 09:59:02 106

原创 82. 删除排序链表中的重复元素 II

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中没有重复出现的数字。返回同样按升序排列的结果链表。示例 1：输入：head = [1,2,3,3,4,4,5]输出：[1,2,5]示例 2：输入：head = [1,1,1,2,3]输出：[2,3]提示：链表中节点数目在范围 [0, 300] 内-100 <= Node.val <= 100题目数据保证链表已经按升序排列解答模拟：/**

2021-03-25 10:35:30 83

原创 456. 132模式

给定一个整数序列：a1, a2, ..., an，一个132模式的子序列ai, aj, ak 被定义为：当 i < j < k 时，ai < ak < aj。设计一个算法，当给定有 n 个数字的序列时，验证这个序列中是否含有132模式的子序列。注意：n 的值小于15000。示例1:输入: [1, 2, 3, 4]输出: False解释: 序列中不存在132模式的子序列。示例 2:输入: [3, 1, 4, 2]输出: True解释: 序列中有 1 个132

2021-03-24 10:45:46 78

原创 341. 扁平化嵌套列表迭代器

给你一个嵌套的整型列表。请你设计一个迭代器，使其能够遍历这个整型列表中的所有整数。列表中的每一项或者为一个整数，或者是另一个列表。其中列表的元素也可能是整数或是其他列表。示例 1:输入: [[1,1],2,[1,1]]输出: [1,1,2,1,1]解释: 通过重复调用 next 直到 hasNext 返回 false，next 返回的元素的顺序应该是: [1,1,2,1,1]。示例 2:输入: [1,[4,[6]]]输出: [1,4,6]解释: 通过重复调用 next 直到 hasNex

2021-03-23 22:38:49 59

原创 73. 矩阵置零

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用原地算法。进阶：一个直观的解决方案是使用 O(mn) 的额外空间，但这并不是一个好的解决方案。一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。你能想出一个仅使用常量空间的解决方案吗？示例 1：输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]输出：[[1,0,1],[0,0,0],[1,0,1]]示例 2：输入：matri

2021-03-21 12:16:14 133

原创 150. 逆波兰表达式求值

根据逆波兰表示法，求表达式的值。有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。说明：整数除法只保留整数部分。给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。示例 1：输入：tokens = ["2","1","+","3","*"]输出：9解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9示例 2：输入：tokens = ["4","13","5","/","+"]输出：6

2021-03-21 11:38:09 69

原创 50. Pow(x, n)

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x^n）。示例 1：输入：x = 2.00000, n = 10输出：1024.00000示例 2：输入：x = 2.10000, n = 3输出：9.26100示例 3：输入：x = 2.00000, n = -2输出：0.25000解释：2-2 = 1/22 = 1/4 = 0.25提示：-100.0 < x < 100.0-2^31 <= n <= 2^31-1-10^4 <

2021-03-20 10:40:28 89

原创 92. 反转链表 II

给你单链表的头节点 head 和两个整数 left 和 right，其中left <= right。请你反转从位置left到位置right` 的链表节点，返回反转后的链表。示例 1：输入：head = [1,2,3,4,5], left = 2, right = 4输出：[1,4,3,2,5]示例 2：输入：head = [5], left = 1, right = 1输出：[5]提示：链表中节点数目为 n1 <= n <= 500-500 <= No

2021-03-18 10:26:34 137

原创 115. 不同的子序列

给定一个字符串 s 和一个字符串t ，计算在 s 的子序列中 t 出现的个数。字符串的一个子序列是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）题目数据保证答案符合 32 位带符号整数范围。示例 1：输入：s = "rabbbit", t = "rabbit"输出：3解释：如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。(上箭头符号 ^ 表示选取的字母)ra

2021-03-17 10:20:13 138

原创 59. 螺旋矩阵 II

给你一个正整数 n ，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。示例 1：输入：n = 3输出：[[1,2,3],[8,9,4],[7,6,5]]示例 2：输入：n = 1输出：[[1]]提示：1 <= n <= 20解答跟上一题54. 螺旋矩阵思路一致：class Solution {public: int dx = 0, dy = 1; vector<vector<

2021-03-16 23:12:14 78

原创 54. 螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照顺时针螺旋顺序，返回矩阵中的所有元素。示例 1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]示例 2：输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]提示：m == matrix.lengthn == matrix[i].length1 <=

2021-03-15 22:38:21 137

原创 706. 设计哈希映射

不使用任何内建的哈希表库设计一个哈希映射（HashMap）。实现 MyHashMap 类：MyHashMap() 用空映射初始化对象void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中，则更新其对应的值 value 。int get(int key) 返回特定的 key 所映射的 value ；如果映射中不包含 key 的映射，返回 -1 。void remove(key) 如果映射中存在 key

2021-03-14 10:53:03 97

原创 705. 设计哈希集合

不使用任何内建的哈希表库设计一个哈希集合（HashSet）。实现 MyHashSet 类：void add(key) 向哈希集合中插入值 key 。bool contains(key) 返回哈希集合中是否存在这个值 key 。void remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。示例：输入：["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "re

2021-03-13 11:37:43 210

原创 331. 验证二叉树的前序序列化

序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时，我们可以记录下这个节点的值。如果它是一个空节点，我们可以使用一个标记值记录，例如 #。 _9_ / \ 3 2 / \ / \ 4 1 # 6/ \ / \ / \# # # # # #例如，上面的二叉树可以被序列化为字符串 "9,3,4,#,#,1,#,#,2,#,6,#,#"，其中 # 代表一个空节点。给定一串以逗号分隔的序列，验证它是否是正确的二叉树的前序序列化。编写

2021-03-12 10:24:22 103

原创 227. 基本计算器 II

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。整数除法仅保留整数部分。示例 1：输入：s = "3+2*2"输出：7示例 2：输入：s = " 3/2 "输出：1示例 3：输入：s = " 3+5 / 2 "输出：5提示：1 <= s.length <= 3 * 10^5s 由整数和算符 ('+', '-', '*', '/') 组成，中间由一些空格隔开s 表示一个有效表达式表达式中的所有整数都是非负整数，且在范围 [0, 2^31

2021-03-11 23:42:35 81

原创 224. 基本计算器

实现一个基本的计算器来计算一个简单的字符串表达式 s 的值。示例 1：输入：s = "1 + 1"输出：2示例 2：输入：s = " 2-1 + 2 "输出：3示例 3：输入：s = "(1+(4+5+2)-3)+(6+8)"输出：23提示：1 <= s.length <= 3 * 105s 由数字、’+’、’-’、’(’、’)’、和 ’ ’ 组成s 表示一个有效的表达式解答由于这道题没有乘除，所以所有运算的优先级一致，即可以从左至右遍历运算。比较麻烦的一

2021-03-10 21:49:41 94

原创 1047. 删除字符串中的所有相邻重复项

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。在 S 上反复执行重复项删除操作，直到无法继续删除。在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。示例：输入："abbaca"输出："ca"解释：例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。提示：1 <=

2021-03-09 10:07:16 67

原创 132. 分割回文串 II

给你一个字符串 ``s，请你将 s 分割成一些子串，使每个子串都是回文。返回符合要求的最少分割次数。示例 1：输入：s = "aab"输出：1解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。示例 2：输入：s = "a"输出：0示例 3：输入：s = "ab"输出：1提示：1 <= s.length <= 2000s 仅由小写英文字母组成解答按照上一题的递归+回溯思路，但会卡超时：class Solution {pr

2021-03-08 10:44:59 89

原创 1411. 给 N x 3 网格图涂色的方案数

你有一个 n x 3 的网格图 grid ，你需要用红，黄，绿三种颜色之一给每一个格子上色，且确保相邻格子颜色不同（也就是有相同水平边或者垂直边的格子颜色不同）。给你网格图的行数 n 。请你返回给 grid 涂色的方案数。由于答案可能会非常大，请你返回答案对 10^9 + 7 取余的结果。示例 1：输入：n = 1输出：12解释：总共有 12 种可行的方法：示例 2：输入：n = 2输出：54示例 3：输入：n = 3输出：246示例 4：输入：n = 7输出：10

2021-03-07 11:19:25 314

原创 131. 分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。示例:输入: "aab"输出:[ ["aa","b"], ["a","a","b"]]解答递归+回溯class Solution {public: vector<vector<string>> partition(string s) { vector<vector<string>> result;

2021-03-07 10:48:36 69

空空如也

空空如也