mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-05 23:41:41 +08:00
批量更新数据
This commit is contained in:
@@ -2,24 +2,24 @@
|
||||
|
||||
<p>返回该子数组，若存在多个最长子数组，返回左端点下标值最小的子数组。若不存在这样的数组，返回一个空数组。</p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>["A","1","B","C","D","2","3","4","E","5","F","G","6","7","H","I","J","K","L","M"]
|
||||
<strong>输入：</strong>["A","1","B","C","D","2","3","4","E","5","F","G","6","7","H","I","J","K","L","M"]
|
||||
|
||||
<strong>输出: </strong>["A","1","B","C","D","2","3","4","E","5","F","G","6","7"]
|
||||
<strong>输出：</strong>["A","1","B","C","D","2","3","4","E","5","F","G","6","7"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>["A","A"]
|
||||
<strong>输入：</strong>["A","A"]
|
||||
|
||||
<strong>输出: </strong>[]
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>array.length <= 100000</code></li>
|
||||
<li><code>array.length <= 100000</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
<p><img alt="" src="https://pic.leetcode-cn.com/1626667205-xFxIeK-image.png" style="width: 150px; " /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>mat =<b> </b>[[0,0,0],[0,1,0],[1,1,1]]
|
||||
<strong>输入：</strong>mat =<b> </b>[[0,0,0],[0,1,0],[1,1,1]]
|
||||
<strong>输出：</strong>[[0,0,0],[0,1,0],[1,2,1]]
|
||||
</pre>
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
<p>给你一个整数 <code>n</code>，请你判断该整数是否是 2 的幂次方。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p>如果存在一个整数 <code>x</code> 使得 <code>n == 2<sup>x</sup></code> ，则认为 <code>n</code> 是 2 的幂次方。</p>
|
||||
<p>如果存在一个整数 <code>x</code> 使得 <code>n == 2<sup>x</sup></code> ，则认为 <code>n</code> 是 2 的幂次方。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -27,28 +27,14 @@
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 4
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 5：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 5
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你能够不使用循环/递归解决此问题吗？</p>
|
||||
|
||||
@@ -28,4 +28,5 @@
|
||||
<li><code>text</code> 中的所有单词之间都由 <strong>单个空格字符</strong> 分隔</li>
|
||||
<li><code>1 <= first.length, second.length <= 10</code></li>
|
||||
<li><code>first</code> 和 <code>second</code> 由小写英文字母组成</li>
|
||||
<li><code>text</code> 不包含任何前缀或尾随空格。</li>
|
||||
</ul>
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>senate = "RD"
|
||||
@@ -26,7 +26,7 @@
|
||||
第 2 轮时，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人</code>。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>senate = "RDD"
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>给你一个整数数组 <code>citations</code> ，其中 <code>citations[i]</code> 表示研究者的第 <code>i</code> 篇论文被引用的次数。计算并返回该研究者的 <strong><code>h</code><em> </em>指数</strong>。</p>
|
||||
|
||||
<p>根据维基百科上 <a href="https://baike.baidu.com/item/h-index/3991452?fr=aladdin" target="_blank">h 指数的定义</a>：<code>h</code> 代表“高引用次数” ，一名科研人员的 <code>h</code><strong> 指数 </strong>是指他（她）至少发表了 <code>h</code> 篇论文，并且每篇论文<strong> 至少</strong> 被引用 <code>h</code> 次。如果 <code>h</code><em> </em>有多种可能的值，<strong><code>h</code> 指数 </strong>是其中最大的那个。</p>
|
||||
<p>根据维基百科上 <a href="https://baike.baidu.com/item/h-index/3991452?fr=aladdin" target="_blank">h 指数的定义</a>：<code>h</code> 代表“高引用次数” ，一名科研人员的 <code>h</code><strong> 指数 </strong>是指他（她）至少发表了 <code>h</code> 篇论文，并且 <strong>至少 </strong>有 <code>h</code> 篇论文被引用次数大于等于 <code>h</code> 。如果 <code>h</code><em> </em>有多种可能的值，<strong><code>h</code> 指数 </strong>是其中最大的那个。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,47 +1,47 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> 和一个整数 <code>k</code> 。你需要执行以下操作<strong> 恰好</strong> <code>k</code> 次，最大化你的得分：</p>
|
||||
|
||||
<ol>
|
||||
<li>从 <code>nums</code> 中选择一个元素 <code>m</code> 。</li>
|
||||
<li>将选中的元素 <code>m</code> 从数组中删除。</li>
|
||||
<li>将新元素 <code>m + 1</code> 添加到数组中。</li>
|
||||
<li>你的得分增加 <code>m</code> 。</li>
|
||||
</ol>
|
||||
|
||||
<p>请你返回执行以上操作恰好 <code>k</code> 次后的最大得分。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [1,2,3,4,5], k = 3
|
||||
<b>输出：</b>18
|
||||
<b>解释：</b>我们需要从 nums 中恰好选择 3 个元素并最大化得分。
|
||||
第一次选择 5 。和为 5 ，nums = [1,2,3,4,6] 。
|
||||
第二次选择 6 。和为 6 ，nums = [1,2,3,4,7] 。
|
||||
第三次选择 7 。和为 5 + 6 + 7 = 18 ，nums = [1,2,3,4,8] 。
|
||||
所以我们返回 18 。
|
||||
18 是可以得到的最大答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [5,5,5], k = 2
|
||||
<b>输出：</b>11
|
||||
<b>解释：</b>我们需要从 nums 中恰好选择 2 个元素并最大化得分。
|
||||
第一次选择 5 。和为 5 ，nums = [5,5,6] 。
|
||||
第二次选择 6 。和为 6 ，nums = [5,5,7] 。
|
||||
所以我们返回 11 。
|
||||
11 是可以得到的最大答案。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 100</code></li>
|
||||
<li><code>1 <= k <= 100</code></li>
|
||||
</ul>
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> 和一个整数 <code>k</code> 。你需要执行以下操作<strong> 恰好</strong> <code>k</code> 次，最大化你的得分：</p>
|
||||
|
||||
<ol>
|
||||
<li>从 <code>nums</code> 中选择一个元素 <code>m</code> 。</li>
|
||||
<li>将选中的元素 <code>m</code> 从数组中删除。</li>
|
||||
<li>将新元素 <code>m + 1</code> 添加到数组中。</li>
|
||||
<li>你的得分增加 <code>m</code> 。</li>
|
||||
</ol>
|
||||
|
||||
<p>请你返回执行以上操作恰好 <code>k</code> 次后的最大得分。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [1,2,3,4,5], k = 3
|
||||
<b>输出：</b>18
|
||||
<b>解释：</b>我们需要从 nums 中恰好选择 3 个元素并最大化得分。
|
||||
第一次选择 5 。和为 5 ，nums = [1,2,3,4,6] 。
|
||||
第二次选择 6 。和为 6 ，nums = [1,2,3,4,7] 。
|
||||
第三次选择 7 。和为 5 + 6 + 7 = 18 ，nums = [1,2,3,4,8] 。
|
||||
所以我们返回 18 。
|
||||
18 是可以得到的最大答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [5,5,5], k = 2
|
||||
<b>输出：</b>11
|
||||
<b>解释：</b>我们需要从 nums 中恰好选择 2 个元素并最大化得分。
|
||||
第一次选择 5 。和为 5 ，nums = [5,5,6] 。
|
||||
第二次选择 6 。和为 6 ，nums = [5,5,7] 。
|
||||
所以我们返回 11 。
|
||||
11 是可以得到的最大答案。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 100</code></li>
|
||||
<li><code>1 <= k <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>逆序对的定义如下：对于数组 <code>nums</code> 的第 <code>i</code> 个和第 <code>j</code> 个元素，如果满足 <code>0 <= i < j < nums.length</code> 且 <code>nums[i] > nums[j]</code>，则其为一个逆序对；否则不是。</p>
|
||||
<p>对于一个整数数组 <code>nums</code>，<strong>逆序对</strong>是一对满足 <code>0 <= i < j < nums.length</code> 且 <code>nums[i] > nums[j]</code>的整数对 <code>[i, j]</code> 。</p>
|
||||
|
||||
<p>给你两个整数 <code>n</code> 和 <code>k</code>，找出所有包含从 <code>1</code> 到 <code>n</code> 的数字，且恰好拥有 <code>k</code> 个 <strong>逆序对</strong> 的不同的数组的个数。由于答案可能很大，只需要返回对 <code>10<sup>9</sup> + 7</code> 取余的结果。</p>
|
||||
|
||||
|
||||
@@ -1,41 +1,41 @@
|
||||
<p>袋子中装有一些物品，每个物品上都标记着数字 <code>1</code> 、<code>0</code> 或 <code>-1</code> 。</p>
|
||||
|
||||
<p>给你四个非负整数 <code>numOnes</code> 、<code>numZeros</code> 、<code>numNegOnes</code> 和 <code>k</code> 。</p>
|
||||
|
||||
<p>袋子最初包含：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>numOnes</code> 件标记为 <code>1</code> 的物品。</li>
|
||||
<li><code>numZeros</code> 件标记为 <code>0</code> 的物品。</li>
|
||||
<li><code>numNegOnes</code> 件标记为 <code>-1</code> 的物品。</li>
|
||||
</ul>
|
||||
|
||||
<p>现计划从这些物品中恰好选出 <code>k</code> 件物品。返回所有可行方案中，物品上所标记数字之和的最大值。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 2 件标记为 1 的物品，得到的数字之和为 2 。
|
||||
可以证明 2 是所有可行方案中的最大值。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 3 件标记为 1 的物品，1 件标记为 0 的物品，得到的数字之和为 3 。
|
||||
可以证明 3 是所有可行方案中的最大值。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= numOnes, numZeros, numNegOnes <= 50</code></li>
|
||||
<li><code>0 <= k <= numOnes + numZeros + numNegOnes</code></li>
|
||||
</ul>
|
||||
<p>袋子中装有一些物品，每个物品上都标记着数字 <code>1</code> 、<code>0</code> 或 <code>-1</code> 。</p>
|
||||
|
||||
<p>给你四个非负整数 <code>numOnes</code> 、<code>numZeros</code> 、<code>numNegOnes</code> 和 <code>k</code> 。</p>
|
||||
|
||||
<p>袋子最初包含：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>numOnes</code> 件标记为 <code>1</code> 的物品。</li>
|
||||
<li><code>numZeros</code> 件标记为 <code>0</code> 的物品。</li>
|
||||
<li><code>numNegOnes</code> 件标记为 <code>-1</code> 的物品。</li>
|
||||
</ul>
|
||||
|
||||
<p>现计划从这些物品中恰好选出 <code>k</code> 件物品。返回所有可行方案中，物品上所标记数字之和的最大值。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 2 件标记为 1 的物品，得到的数字之和为 2 。
|
||||
可以证明 2 是所有可行方案中的最大值。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 3 件标记为 1 的物品，1 件标记为 0 的物品，得到的数字之和为 3 。
|
||||
可以证明 3 是所有可行方案中的最大值。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= numOnes, numZeros, numNegOnes <= 50</code></li>
|
||||
<li><code>0 <= k <= numOnes + numZeros + numNegOnes</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> ，它表示一个 <strong>栈</strong> ，其中 <code>nums[0]</code> 是栈顶的元素。</p>
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> ，它表示一个 <strong>堆</strong> ，其中 <code>nums[0]</code> 是堆顶的元素。</p>
|
||||
|
||||
<p>每一次操作中，你可以执行以下操作 <strong>之一</strong> ：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果栈非空，那么 <strong>删除</strong> 栈顶端的元素。</li>
|
||||
<li>如果存在 1 个或者多个被删除的元素，你可以从它们中选择任何一个，<b>添加</b> 回栈顶，这个元素成为新的栈顶元素。</li>
|
||||
<li>如果堆非空，那么 <strong>删除</strong> 堆顶端的元素。</li>
|
||||
<li>如果存在 1 个或者多个被删除的元素，你可以从它们中选择任何一个，<b>添加</b> 回堆顶，这个元素成为新的堆顶元素。</li>
|
||||
</ul>
|
||||
|
||||
<p>同时给你一个整数 <code>k</code> ，它表示你总共需要执行操作的次数。</p>
|
||||
|
||||
<p>请你返回 <strong>恰好</strong> 执行 <code>k</code> 次操作以后，栈顶元素的 <strong>最大值</strong> 。如果执行完 <code>k</code> 次操作以后，栈一定为空，请你返回 <code>-1</code> 。</p>
|
||||
<p>请你返回 <strong>恰好</strong> 执行 <code>k</code> 次操作以后，堆顶元素的 <strong>最大值</strong> 。如果执行完 <code>k</code> 次操作以后，堆一定为空，请你返回 <code>-1</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -19,12 +19,12 @@
|
||||
<b>输入：</b>nums = [5,2,2,4,0,6], k = 4
|
||||
<b>输出：</b>5
|
||||
<strong>解释：</strong>
|
||||
4 次操作后，栈顶元素为 5 的方法之一为：
|
||||
- 第 1 次操作：删除栈顶元素 5 ，栈变为 [2,2,4,0,6] 。
|
||||
- 第 2 次操作：删除栈顶元素 2 ，栈变为 [2,4,0,6] 。
|
||||
- 第 3 次操作：删除栈顶元素 2 ，栈变为 [4,0,6] 。
|
||||
- 第 4 次操作：将 5 添加回栈顶，栈变为 [5,4,0,6] 。
|
||||
注意，这不是最后栈顶元素为 5 的唯一方式。但可以证明，4 次操作以后 5 是能得到的最大栈顶元素。
|
||||
4 次操作后，堆顶元素为 5 的方法之一为：
|
||||
- 第 1 次操作：删除堆顶元素 5 ，堆变为 [2,2,4,0,6] 。
|
||||
- 第 2 次操作：删除堆顶元素 2 ，堆变为 [2,4,0,6] 。
|
||||
- 第 3 次操作：删除堆顶元素 2 ，堆变为 [4,0,6] 。
|
||||
- 第 4 次操作：将 5 添加回堆顶，堆变为 [5,4,0,6] 。
|
||||
注意，这不是最后堆顶元素为 5 的唯一方式。但可以证明，4 次操作以后 5 是能得到的最大堆顶元素。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
@@ -33,8 +33,8 @@
|
||||
<b>输入：</b>nums = [2], k = 1
|
||||
<b>输出：</b>-1
|
||||
<b>解释：</b>
|
||||
第 1 次操作中，我们唯一的选择是将栈顶元素弹出栈。
|
||||
由于 1 次操作后无法得到一个非空的栈，所以我们返回 -1 。
|
||||
第 1 次操作中，我们唯一的选择是将堆顶元素弹出堆。
|
||||
由于 1 次操作后无法得到一个非空的堆，所以我们返回 -1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -5,32 +5,36 @@
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-3drawio.png" style="width: 332px; height: 392px;" />
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
|
||||
src = 0, dst = 2, k = 1
|
||||
<strong>输出:</strong> 200
|
||||
<strong>解释:</strong>
|
||||
城市航班图如下
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png" style="height: 180px; width: 246px;" />
|
||||
|
||||
从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200，如图中红色所示。</pre>
|
||||
n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1
|
||||
<strong>输出:</strong> 700
|
||||
<strong>解释:</strong> 城市航班图如上
|
||||
从城市 0 到城市 3 经过最多 1 站的最佳路径用红色标记，费用为 100 + 600 = 700。
|
||||
请注意，通过城市 [0, 1, 2, 3] 的路径更便宜，但无效，因为它经过了 2 站。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-1drawio.png" style="width: 332px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
|
||||
src = 0, dst = 2, k = 0
|
||||
<strong>输出:</strong> 500
|
||||
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1
|
||||
<strong>输出:</strong> 200
|
||||
<strong>解释:</strong>
|
||||
城市航班图如下
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png" style="height: 180px; width: 246px;" />
|
||||
城市航班图如上
|
||||
从城市 0 到城市 2 经过最多 1 站的最佳路径标记为红色，费用为 100 + 100 = 200。
|
||||
</pre>
|
||||
|
||||
从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500，如图中蓝色所示。</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/18/cheapest-flights-within-k-stops-2drawio.png" style="width: 332px; height: 242px;" />
|
||||
<pre>
|
||||
<b>输入：</b>n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0
|
||||
<b>输出：</b>500
|
||||
<strong>解释：</strong>
|
||||
城市航班图如上
|
||||
从城市 0 到城市 2 不经过站点的最佳路径标记为红色，费用为 500。
|
||||
</pre>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
|
||||
@@ -1,13 +1,14 @@
|
||||
<p>设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。</p>
|
||||
<p>设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。</p>
|
||||
|
||||
<p>它应该支持以下操作： 获取数据 <code>get</code> 和 写入数据 <code>put</code> 。</p>
|
||||
|
||||
<p>获取数据 <code>get(key)</code> - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。<br>
|
||||
<p>获取数据 <code>get(key)</code> - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。<br />
|
||||
写入数据 <code>put(key, value)</code> - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。</p>
|
||||
|
||||
<p><strong>示例:</strong></p>
|
||||
<p><strong>示例：</strong></p>
|
||||
|
||||
<pre>LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
|
||||
<pre>
|
||||
LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
|
||||
|
||||
cache.put(1, 1);
|
||||
cache.put(2, 2);
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="height: 193px; width: 300px;" /></p>
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
<strong>输出：</strong>[5,6,3,2,4,1]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="height: 269px; width: 296px;" /></p>
|
||||
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
|
||||
<p>树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;" /></p>
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
<strong>输出：</strong>[[1],[3,2,4],[5,6]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;" /></p>
|
||||
|
||||
@@ -22,11 +22,11 @@
|
||||
<strong>输出：</strong>[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树的高度不会超过 <code>1000</code></li>
|
||||
<li>树的节点总数在 <code>[0, 10^4]</code> 之间</li>
|
||||
<li>树的高度不会超过 <code>1000</code></li>
|
||||
<li>树的节点总数在 <code>[0, 10<sup>4</sup>]</code> 之间</li>
|
||||
</ul>
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 :</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>inputs = ["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
|
||||
|
||||
@@ -1,73 +0,0 @@
|
||||
<p>请你编写一个异步函数 <code>promisePool</code> ，它接收一个异步函数数组 <code>functions</code> 和 <strong>池限制</strong> <code>n</code>。它应该返回一个 promise 对象，当所有输入函数都执行完毕后，promise 对象就执行完毕。</p>
|
||||
|
||||
<p><strong>池限制</strong> 定义是一次可以挂起的最多 promise 对象的数量。<code>promisePool</code> 应该开始执行尽可能多的函数，并在旧的 promise 执行完毕后继续执行新函数。<code>promisePool</code> 应该先执行 <code>functions[i]</code>，再执行 <code>functions[i + 1]</code>，然后执行 <code>functions[i + 2]</code>，等等。当最后一个 promise 执行完毕时，<code>promisePool</code> 也应该执行完毕。</p>
|
||||
|
||||
<p>例如，如果 <code>n = 1</code> , <code>promisePool</code> 在序列中每次执行一个函数。然而，如果 <code>n = 2</code> ，它首先执行两个函数。当两个函数中的任何一个执行完毕后，再执行第三个函数(如果它是可用的)，依此类推，直到没有函数要执行为止。</p>
|
||||
|
||||
<p>你可以假设所有的 <code>functions</code> 都不会被拒绝。对于 <code>promisePool</code> 来说，返回一个可以解析任何值的 promise 都是可以接受的。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
functions = [
|
||||
() => new Promise(res => setTimeout(res, 300)),
|
||||
() => new Promise(res => setTimeout(res, 400)),
|
||||
() => new Promise(res => setTimeout(res, 200))
|
||||
]
|
||||
n = 2
|
||||
<b>输出：</b>[[300,400,500],500]
|
||||
<strong>解释</strong>
|
||||
传递了三个函数。它们的睡眠时间分别为 300ms、 400ms 和 200ms。
|
||||
在 t=0 时，执行前两个函数。池大小限制达到 2。
|
||||
当 t=300 时，第一个函数执行完毕后，执行第3个函数。池大小为 2。
|
||||
在 t=400 时，第二个函数执行完毕后。没有什么可执行的了。池大小为 1。
|
||||
在 t=500 时，第三个函数执行完毕后。池大小为 0，因此返回的 promise 也执行完成。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：
|
||||
</strong>functions = [
|
||||
() => new Promise(res => setTimeout(res, 300)),
|
||||
() => new Promise(res => setTimeout(res, 400)),
|
||||
() => new Promise(res => setTimeout(res, 200))
|
||||
]
|
||||
n = 5
|
||||
<b>输出：</b>[[300,400,200],400]
|
||||
<strong>解释：</strong>
|
||||
在 t=0 时，所有3个函数都被执行。池的限制大小 5 永远不会满足。
|
||||
在 t=200 时，第三个函数执行完毕后。池大小为 2。
|
||||
在 t=300 时，第一个函数执行完毕后。池大小为 1。
|
||||
在 t=400 时，第二个函数执行完毕后。池大小为 0，因此返回的 promise 也执行完成。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>
|
||||
functions = [
|
||||
() => new Promise(res => setTimeout(res, 300)),
|
||||
() => new Promise(res => setTimeout(res, 400)),
|
||||
() => new Promise(res => setTimeout(res, 200))
|
||||
]
|
||||
n = 1
|
||||
<b>输出：</b>[[300,700,900],900]
|
||||
<strong>解释：</strong>
|
||||
在 t=0 时，执行第一个函数。池大小为1。
|
||||
当 t=300 时，第一个函数执行完毕后，执行第二个函数。池大小为 1。
|
||||
当 t=700 时，第二个函数执行完毕后，执行第三个函数。池大小为 1。
|
||||
在 t=900 时，第三个函数执行完毕后。池大小为 0，因此返回的 Promise 也执行完成。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= functions.length <= 10</code></li>
|
||||
<li><code><font face="monospace">1 <= n <= 10</font></code></li>
|
||||
</ul>
|
||||
@@ -6,14 +6,14 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> x = 4
|
||||
<strong>输出:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> x = 8
|
||||
@@ -23,7 +23,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><meta charset="UTF-8" /><code>0 <= x <= 2<sup>31</sup> - 1</code></li>
|
||||
|
||||
@@ -1,28 +1,31 @@
|
||||
<p>给你一个字符串 <code>text</code>，你需要使用 <code>text</code> 中的字母来拼凑尽可能多的单词 <strong>"balloon"（气球）</strong>。</p>
|
||||
<p>给你一个字符串 <code>text</code>，你需要使用 <code>text</code> 中的字母来拼凑尽可能多的单词 <strong>"balloon"（气球）</strong>。</p>
|
||||
|
||||
<p>字符串 <code>text</code> 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 <strong>"balloon"</strong>。</p>
|
||||
<p>字符串 <code>text</code> 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 <strong>"balloon"</strong>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/14/1536_ex1_upd.jpeg" style="height: 35px; width: 154px;"></strong></p>
|
||||
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/14/1536_ex1_upd.jpeg" style="height: 35px; width: 154px;" /></strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>text = "nlaebolko"
|
||||
<pre>
|
||||
<strong>输入：</strong>text = "nlaebolko"
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/14/1536_ex2_upd.jpeg" style="height: 35px; width: 233px;"></strong></p>
|
||||
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/14/1536_ex2_upd.jpeg" style="height: 35px; width: 233px;" /></strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>text = "loonbalxballpoon"
|
||||
<pre>
|
||||
<strong>输入：</strong>text = "loonbalxballpoon"
|
||||
<strong>输出：</strong>2
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>text = "leetcode"
|
||||
<pre>
|
||||
<strong>输入：</strong>text = "leetcode"
|
||||
<strong>输出：</strong>0
|
||||
</pre>
|
||||
|
||||
@@ -31,6 +34,10 @@
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= text.length <= 10^4</code></li>
|
||||
<li><code>1 <= text.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>text</code> 全部由小写英文字母组成</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>注意：</strong>本题与 <a href="https://leetcode.cn/problems/rearrange-characters-to-make-target-string/">2287. 重排字符形成目标字符串</a> 相同。</p>
|
||||
|
||||
@@ -1,28 +1,28 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> ，它表示一个班级中所有学生在一次考试中的成绩。老师想选出一部分同学组成一个 <strong>非空</strong> 小组，且这个小组的 <strong>实力值</strong> 最大，如果这个小组里的学生下标为 <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, <code>i<sub>2</sub></code>, ... , <code>i<sub>k</sub></code> ，那么这个小组的实力值定义为 <code>nums[i<sub>0</sub>] * nums[i<sub>1</sub>] * nums[i<sub>2</sub>] * ... * nums[i<sub>k</sub>]</code> 。</p>
|
||||
|
||||
<p>请你返回老师创建的小组能得到的最大实力值为多少。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [3,-1,-5,2,5,-9]
|
||||
<strong>输出：</strong>1350
|
||||
<b>解释：</b>一种构成最大实力值小组的方案是选择下标为 [0,2,3,4,5] 的学生。实力值为 3 * (-5) * 2 * 5 * (-9) = 1350 ，这是可以得到的最大实力值。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [-4,-5,-4]
|
||||
<b>输出：</b>20
|
||||
<b>解释：</b>选择下标为 [0, 1] 的学生。得到的实力值为 20 。我们没法得到更大的实力值。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 13</code></li>
|
||||
<li><code>-9 <= nums[i] <= 9</code></li>
|
||||
</ul>
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的整数数组 <code>nums</code> ，它表示一个班级中所有学生在一次考试中的成绩。老师想选出一部分同学组成一个 <strong>非空</strong> 小组，且这个小组的 <strong>实力值</strong> 最大，如果这个小组里的学生下标为 <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, <code>i<sub>2</sub></code>, ... , <code>i<sub>k</sub></code> ，那么这个小组的实力值定义为 <code>nums[i<sub>0</sub>] * nums[i<sub>1</sub>] * nums[i<sub>2</sub>] * ... * nums[i<sub>k</sub>]</code> 。</p>
|
||||
|
||||
<p>请你返回老师创建的小组能得到的最大实力值为多少。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [3,-1,-5,2,5,-9]
|
||||
<strong>输出：</strong>1350
|
||||
<b>解释：</b>一种构成最大实力值小组的方案是选择下标为 [0,2,3,4,5] 的学生。实力值为 3 * (-5) * 2 * 5 * (-9) = 1350 ，这是可以得到的最大实力值。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [-4,-5,-4]
|
||||
<b>输出：</b>20
|
||||
<b>解释：</b>选择下标为 [0, 1] 的学生。得到的实力值为 20 。我们没法得到更大的实力值。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 13</code></li>
|
||||
<li><code>-9 <= nums[i] <= 9</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,45 +1,45 @@
|
||||
<p>定义一个数组 <code>arr</code> 的 <strong>转换数组</strong> <code>conver</code> 为：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>conver[i] = arr[i] + max(arr[0..i])</code>，其中 <code>max(arr[0..i])</code> 是满足 <code>0 <= j <= i</code> 的所有 <code>arr[j]</code> 中的最大值。</li>
|
||||
</ul>
|
||||
|
||||
<p>定义一个数组 <code>arr</code> 的 <strong>分数</strong> 为 <code>arr</code> 转换数组中所有元素的和。</p>
|
||||
|
||||
<p>给你一个下标从 <strong>0</strong> 开始长度为 <code>n</code> 的整数数组 <code>nums</code> ，请你返回一个长度为 <code>n</code> 的数组<em> </em><code>ans</code> ，其中 <code>ans[i]</code>是前缀 <code>nums[0..i]</code> 的分数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [2,3,7,5,10]
|
||||
<b>输出：</b>[4,10,24,36,56]
|
||||
<b>解释：</b>
|
||||
对于前缀 [2] ，转换数组为 [4] ，所以分数为 4 。
|
||||
对于前缀 [2, 3] ，转换数组为 [4, 6] ，所以分数为 10 。
|
||||
对于前缀 [2, 3, 7] ，转换数组为 [4, 6, 14] ，所以分数为 24 。
|
||||
对于前缀 [2, 3, 7, 5] ，转换数组为 [4, 6, 14, 12] ，所以分数为 36 。
|
||||
对于前缀 [2, 3, 7, 5, 10] ，转换数组为 [4, 6, 14, 12, 20] ，所以分数为 56 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1,1,2,4,8,16]
|
||||
<b>输出：</b>[2,4,8,16,32,64]
|
||||
<b>解释：</b>
|
||||
对于前缀 [1] ，转换数组为 [2] ，所以分数为 2 。
|
||||
对于前缀 [1, 1]，转换数组为 [2, 2] ，所以分数为 4 。
|
||||
对于前缀 [1, 1, 2]，转换数组为 [2, 2, 4] ，所以分数为 8 。
|
||||
对于前缀 [1, 1, 2, 4]，转换数组为 [2, 2, 4, 8] ，所以分数为 16 。
|
||||
对于前缀 [1, 1, 2, 4, 8]，转换数组为 [2, 2, 4, 8, 16] ，所以分数为 32 。
|
||||
对于前缀 [1, 1, 2, 4, 8, 16]，转换数组为 [2, 2, 4, 8, 16, 32] ，所以分数为 64 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
<p>定义一个数组 <code>arr</code> 的 <strong>转换数组</strong> <code>conver</code> 为：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>conver[i] = arr[i] + max(arr[0..i])</code>，其中 <code>max(arr[0..i])</code> 是满足 <code>0 <= j <= i</code> 的所有 <code>arr[j]</code> 中的最大值。</li>
|
||||
</ul>
|
||||
|
||||
<p>定义一个数组 <code>arr</code> 的 <strong>分数</strong> 为 <code>arr</code> 转换数组中所有元素的和。</p>
|
||||
|
||||
<p>给你一个下标从 <strong>0</strong> 开始长度为 <code>n</code> 的整数数组 <code>nums</code> ，请你返回一个长度为 <code>n</code> 的数组<em> </em><code>ans</code> ，其中 <code>ans[i]</code>是前缀 <code>nums[0..i]</code> 的分数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [2,3,7,5,10]
|
||||
<b>输出：</b>[4,10,24,36,56]
|
||||
<b>解释：</b>
|
||||
对于前缀 [2] ，转换数组为 [4] ，所以分数为 4 。
|
||||
对于前缀 [2, 3] ，转换数组为 [4, 6] ，所以分数为 10 。
|
||||
对于前缀 [2, 3, 7] ，转换数组为 [4, 6, 14] ，所以分数为 24 。
|
||||
对于前缀 [2, 3, 7, 5] ，转换数组为 [4, 6, 14, 12] ，所以分数为 36 。
|
||||
对于前缀 [2, 3, 7, 5, 10] ，转换数组为 [4, 6, 14, 12, 20] ，所以分数为 56 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1,1,2,4,8,16]
|
||||
<b>输出：</b>[2,4,8,16,32,64]
|
||||
<b>解释：</b>
|
||||
对于前缀 [1] ，转换数组为 [2] ，所以分数为 2 。
|
||||
对于前缀 [1, 1]，转换数组为 [2, 2] ，所以分数为 4 。
|
||||
对于前缀 [1, 1, 2]，转换数组为 [2, 2, 4] ，所以分数为 8 。
|
||||
对于前缀 [1, 1, 2, 4]，转换数组为 [2, 2, 4, 8] ，所以分数为 16 。
|
||||
对于前缀 [1, 1, 2, 4, 8]，转换数组为 [2, 2, 4, 8, 16] ，所以分数为 32 。
|
||||
对于前缀 [1, 1, 2, 4, 8, 16]，转换数组为 [2, 2, 4, 8, 16, 32] ，所以分数为 64 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,41 +1,41 @@
|
||||
<p>给你一个大小为 <code>m x n</code> 的二进制矩阵 <code>mat</code> ，请你找出包含最多 <strong>1</strong> 的行的下标（从 <strong>0</strong> 开始）以及这一行中 <strong>1</strong> 的数目。</p>
|
||||
|
||||
<p>如果有多行包含最多的 1 ，只需要选择 <strong>行下标最小</strong> 的那一行。</p>
|
||||
|
||||
<p>返回一个由行下标和该行中 1 的数量组成的数组。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[0,1],[1,0]]
|
||||
<strong>输出：</strong>[0,1]
|
||||
<strong>解释：</strong>两行中 1 的数量相同。所以返回下标最小的行，下标为 0 。该行 1 的数量为 1 。所以，答案为 [0,1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[0,0,0],[0,1,1]]
|
||||
<strong>输出：</strong>[1,2]
|
||||
<strong>解释：</strong>下标为 1 的行中 1 的数量最多<code>。</code>该行 1 的数量<code>为 2 。所以，答案为</code> [1,2] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[0,0],[1,1],[0,0]]
|
||||
<strong>输出：</strong>[1,2]
|
||||
<strong>解释：</strong>下标为 1 的行中 1 的数量最多。该行 1 的数量<code>为 2 。所以，答案为</code> [1,2] 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == mat.length</code> </li>
|
||||
<li><code>n == mat[i].length</code> </li>
|
||||
<li><code>1 <= m, n <= 100</code> </li>
|
||||
<li><code>mat[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
|
||||
</ul>
|
||||
<p>给你一个大小为 <code>m x n</code> 的二进制矩阵 <code>mat</code> ，请你找出包含最多 <strong>1</strong> 的行的下标（从 <strong>0</strong> 开始）以及这一行中 <strong>1</strong> 的数目。</p>
|
||||
|
||||
<p>如果有多行包含最多的 1 ，只需要选择 <strong>行下标最小</strong> 的那一行。</p>
|
||||
|
||||
<p>返回一个由行下标和该行中 1 的数量组成的数组。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[0,1],[1,0]]
|
||||
<strong>输出：</strong>[0,1]
|
||||
<strong>解释：</strong>两行中 1 的数量相同。所以返回下标最小的行，下标为 0 。该行 1 的数量为 1 。所以，答案为 [0,1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[0,0,0],[0,1,1]]
|
||||
<strong>输出：</strong>[1,2]
|
||||
<strong>解释：</strong>下标为 1 的行中 1 的数量最多<code>。</code>该行 1 的数量<code>为 2 。所以，答案为</code> [1,2] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[0,0],[1,1],[0,0]]
|
||||
<strong>输出：</strong>[1,2]
|
||||
<strong>解释：</strong>下标为 1 的行中 1 的数量最多。该行 1 的数量<code>为 2 。所以，答案为</code> [1,2] 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == mat.length</code> </li>
|
||||
<li><code>n == mat[i].length</code> </li>
|
||||
<li><code>1 <= m, n <= 100</code> </li>
|
||||
<li><code>mat[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -2,21 +2,21 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
<strong>输入：</strong>
|
||||
first = "pale"
|
||||
second = "ple"
|
||||
<strong>输出:</strong> True</pre>
|
||||
<strong>输出：</strong>True</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
<strong>输入：</strong>
|
||||
first = "pales"
|
||||
second = "pal"
|
||||
<strong>输出:</strong> False
|
||||
<strong>输出：</strong>False
|
||||
</pre>
|
||||
|
||||
@@ -1,19 +1,19 @@
|
||||
<p>给你一个整数数组 <code>nums</code> 和一个整数 <code>k</code> ，找出三个长度为 <code>k</code> 、互不重叠、且全部数字和（<code>3 * k</code> 项）最大的子数组，并返回这三个子数组。</p>
|
||||
<p>给你一个整数数组 <code>nums</code> 和一个整数 <code>k</code> ，找出三个长度为 <code>k</code> 、互不重叠、且全部数字和最大的子数组，并返回这三个子数组。</p>
|
||||
|
||||
<p>以下标的数组形式返回结果，数组中的每一项分别指示每个子数组的起始位置（下标从 <strong>0</strong> 开始）。如果有多个结果，返回字典序最小的一个。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,1,2,6,7,5,1], k = 2
|
||||
<strong>输出：</strong>[0,3,5]
|
||||
<strong>解释：</strong>子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。
|
||||
也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。
|
||||
也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更小。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,1,2,1,2,1,2,1], k = 2
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
<p>构造函数会传入一个<code>stackSize</code>参数，代表每个栈的大小。</p>
|
||||
|
||||
<p><strong>示例1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> 输入</strong>：
|
||||
@@ -15,7 +15,7 @@
|
||||
<strong>说明</strong>：当栈为空时`pop, peek`返回-1，当栈满时`push`不压入元素。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> 输入</strong>：
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
<p>给你一个整数数组 <code>nums</code> ，判断是否存在三元组 <code>[nums[i], nums[j], nums[k]]</code> 满足 <code>i != j</code>、<code>i != k</code> 且 <code>j != k</code> ，同时还满足 <code>nums[i] + nums[j] + nums[k] == 0</code> 。请</p>
|
||||
|
||||
<p>你返回所有和为 <code>0</code> 且不重复的三元组。</p>
|
||||
<p>给你一个整数数组 <code>nums</code> ，判断是否存在三元组 <code>[nums[i], nums[j], nums[k]]</code> 满足 <code>i != j</code>、<code>i != k</code> 且 <code>j != k</code> ，同时还满足 <code>nums[i] + nums[j] + nums[k] == 0</code> 。请你返回所有和为 <code>0</code> 且不重复的三元组。</p>
|
||||
|
||||
<p><strong>注意：</strong>答案中不可以包含重复的三元组。</p>
|
||||
|
||||
|
||||
@@ -1,36 +1,47 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的字符串数组 <code>words</code> ，其中 <code>words[i]</code> 要么是一个字符串形式的正整数，要么是字符串 <code>"prev"</code> 。</p>
|
||||
<p>给你一个整数数组 <code>nums</code> ，其中 <code>nums[i]</code> 要么是一个正整数，要么是 <code>-1</code> 。我们需要为每个 <code>-1</code> 找到相应的正整数，我们称之为最后访问的整数。</p>
|
||||
|
||||
<p>我们从数组的开头开始遍历，对于 <code>words</code> 中的每个 <code>"prev"</code> 字符串，找到 <code>words</code> 中的 <strong>上一个遍历的整数</strong> ，定义如下：</p>
|
||||
<p>为了达到这个目标，定义两个空数组：<code>seen</code> 和 <code>ans</code>。</p>
|
||||
|
||||
<p>从数组 <code>nums</code> 的头部开始遍历。</p>
|
||||
|
||||
<ul>
|
||||
<li><code>k</code> 表示到当前位置为止的连续 <code>"prev"</code> 字符串数目（包含当前字符串），令下标从 <strong>0</strong> 开始的 <strong>整数</strong> 数组 <code>nums</code> 表示目前为止遍历过的所有整数，同时用 <code>nums_reverse</code> 表示 <code>nums</code> 反转得到的数组，那么当前 <code>"prev"</code> 对应的 <strong>上一个遍历的整数</strong> 是 <code>nums_reverse</code> 数组中下标为 <code>(k - 1)</code> 的整数。</li>
|
||||
<li>如果 <code>k</code> 比目前为止遍历过的整数数目 <strong>更多</strong> ，那么上一个遍历的整数为 <code>-1</code> 。</li>
|
||||
<li>如果遇到正整数，把它添加到 <code>seen</code> 的 <strong>头部</strong>。</li>
|
||||
<li>如果遇到 <code>-1</code>，则设 <code>k</code> 是到目前为止看到的 <strong>连续</strong> <code>-1</code> 的数目(包括当前 <code>-1</code>)，
|
||||
<ul>
|
||||
<li>如果 <code>k</code> 小于等于 <code>seen</code> 的长度，把 <code>seen</code> 的第 <code>k</code> 个元素添加到 <code>ans</code>。</li>
|
||||
<li>如果 <code>k</code> 严格大于 <code>seen</code> 的长度，把 <code>-1</code> 添加到 <code>ans</code>。</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回一个整数数组，包含所有上一个遍历的整数。</p>
|
||||
<p>请你返回数组 <code>ans</code>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b><code>words</code> = ["1","2","prev","prev","prev"]
|
||||
<b>输入：</b>nums = [1,2,-1,-1,-1]
|
||||
<b>输出：</b>[2,1,-1]
|
||||
<b>解释：</b>
|
||||
对于下标为 2 处的 "prev" ，上一个遍历的整数是 2 ，因为连续 "prev" 数目为 1 ，同时在数组 reverse_nums 中，第一个元素是 2 。
|
||||
对于下标为 3 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev" 数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。
|
||||
对于下标为 4 处的 "prev" ，上一个遍历的整数是 -1 ，因为连续 "prev" 数目为 3 ，但总共只遍历过 2 个整数。
|
||||
<b>解释：</b> 开始时 seen = [] 且 ans = []。
|
||||
1.处理 nums[0]：nums 中的第一个元素是 1。我们将其放在 seen 的前面。现在，seen == [1]。
|
||||
2.处理 nums[1]：下一个元素是 2。我们将其放在 seen 的前面。现在，seen == [2, 1]。
|
||||
3.处理 nums[2]：下一个元素是 -1。这是 -1 的第一次出现，所以 k == 1。我们找到 seen 中的第一个元素，把 2 添加到 ans。现在，ans == [2]。
|
||||
4.处理 nums[3]：又一个 -1。这是 -1 的第二次出现，所以 k == 2。seen 中的第二个元素是 1，所以我们把 1 添加到 ans。现在，ans == [2, 1]。
|
||||
5.处理 nums[4]：又一个 -1。第三次出现，让 k = 3。然而，seen 中只有两个元素（[2, 1]）。因为 k 比 seen 中的元素数量更大，我们把 -1 添加到 ans。最终，ans == [2, 1, -1]。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b><code>words</code> = ["1","prev","2","prev","prev"]
|
||||
<b>输入：</b>nums = [1,-1,2,-1,-1]
|
||||
<b>输出：</b>[1,2,1]
|
||||
<strong>解释：</strong>
|
||||
对于下标为 1 处的 "prev" ，上一个遍历的整数是 1 。
|
||||
对于下标为 3 处的 "prev" ，上一个遍历的整数是 2 。
|
||||
对于下标为 4 处的 "prev" ，上一个遍历的整数是 1 ，因为连续 "prev"<strong> </strong>数目为 2 ，同时在数组 reverse_nums 中，第二个元素是 1 。
|
||||
<strong>解释：</strong> 开始时 seen = [] 且 ans = []。
|
||||
1.处理 nums[0]：nums 中的第一个元素是 1。我们将其放在 seen 的前面。现在，seen == [1]。
|
||||
2.处理 nums[1]：下一个元素是 -1。这是 -1 的第一次出现，所以 k == 1。我们找到 seen 中的第一个元素，即 1。把 1 添加到 ans。现在，ans == [1]。
|
||||
3.处理 nums[2]：下一个元素是 2。我们将其放在 seen 的前面。现在，seen == [2, 1]。
|
||||
4.处理 nums[3]：下一个元素是 -1。这个 -1 与 第一个 -1 不连续，因为中间有个 2。因此，k 重置为 1。seen 中的第一个元素是 2，所以我们把 2 添加到 ans。现在，ans == [1, 2]。
|
||||
5.处理 nums[4]：又一个 -1。它与前一个 -1 相邻，所以 k == 2。seen 中的第 2 个元素是 1。把 1 添加到 ans。最终，ans == [1, 2, 1]。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
@@ -38,6 +49,6 @@
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 100</code></li>
|
||||
<li><code>words[i] == "prev"</code> 或 <code>1 <= int(words[i]) <= 100</code></li>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>nums[i] == -1</code> 或 <code>1 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -2,10 +2,10 @@
|
||||
|
||||
<ol>
|
||||
<li>从 <code>s</code> 中选出 <strong>最小</strong> 的字符，将它 <strong>接在</strong> 结果字符串的后面。</li>
|
||||
<li>从 <code>s</code> 剩余字符中选出 <strong>最小</strong> 的字符，且该字符比上一个添加的字符大，将它 <strong>接在</strong> 结果字符串后面。</li>
|
||||
<li>从 <code>s</code> 剩余字符中选出比上一个添加字符更大的 <strong>最小</strong> 字符，将它 <strong>接在</strong> 结果字符串后面。</li>
|
||||
<li>重复步骤 2 ，直到你没法从 <code>s</code> 中选择字符。</li>
|
||||
<li>从 <code>s</code> 中选出 <strong>最大</strong> 的字符，将它 <strong>接在</strong> 结果字符串的后面。</li>
|
||||
<li>从 <code>s</code> 剩余字符中选出 <strong>最大</strong> 的字符，且该字符比上一个添加的字符小，将它 <strong>接在</strong> 结果字符串后面。</li>
|
||||
<li>从 <code>s</code> 剩余字符中选出比上一个添加字符更小的 <strong>最大</strong> 字符，将它 <strong>接在</strong> 结果字符串后面。</li>
|
||||
<li>重复步骤 5 ，直到你没法从 <code>s</code> 中选择字符。</li>
|
||||
<li>重复步骤 1 到 6 ，直到 <code>s</code> 中所有字符都已经被选过。</li>
|
||||
</ol>
|
||||
@@ -18,38 +18,22 @@
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "aaaabbbbcccc"
|
||||
<strong>输出：</strong>"abccbaabccba"
|
||||
<strong>解释：</strong>第一轮的步骤 1，2，3 后，结果字符串为 result = "abc"
|
||||
第一轮的步骤 4，5，6 后，结果字符串为 result = "abccba"
|
||||
第一轮结束，现在 s = "aabbcc" ，我们再次回到步骤 1
|
||||
第二轮的步骤 1，2，3 后，结果字符串为 result = "abccbaabc"
|
||||
第二轮的步骤 4，5，6 后，结果字符串为 result = "abccbaabccba"
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "aaaabbbbcccc"
|
||||
<strong>输出：</strong>"abccbaabccba"
|
||||
<strong>解释：</strong>第一轮的步骤 1，2，3 后，结果字符串为 result = "abc"
|
||||
第一轮的步骤 4，5，6 后，结果字符串为 result = "abccba"
|
||||
第一轮结束，现在 s = "aabbcc" ，我们再次回到步骤 1
|
||||
第二轮的步骤 1，2，3 后，结果字符串为 result = "abccbaabc"
|
||||
第二轮的步骤 4，5，6 后，结果字符串为 result = "abccbaabccba"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "rat"
|
||||
<strong>输出：</strong>"art"
|
||||
<strong>解释：</strong>单词 "rat" 在上述算法重排序以后变成 "art"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "leetcode"
|
||||
<strong>输出：</strong>"cdelotee"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "ggggggg"
|
||||
<strong>输出：</strong>"ggggggg"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 5：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s = "spo"
|
||||
<strong>输出：</strong>"ops"
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "rat"
|
||||
<strong>输出：</strong>"art"
|
||||
<strong>解释：</strong>单词 "rat" 在上述算法重排序以后变成 "art"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
| temperature | int |
|
||||
+---------------+---------+
|
||||
id 是该表具有唯一值的列。
|
||||
没有具有相同 recordDate 的不同行。
|
||||
该表包含特定日期的温度信息</pre>
|
||||
|
||||
<p> </p>
|
||||
@@ -26,8 +27,8 @@ id 是该表具有唯一值的列。
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<code><strong>输入：</strong>
|
||||
Weather 表：</code>
|
||||
<strong>输入：</strong>
|
||||
Weather 表：
|
||||
+----+------------+-------------+
|
||||
| id | recordDate | Temperature |
|
||||
+----+------------+-------------+
|
||||
|
||||
@@ -1,22 +1,22 @@
|
||||
<p>下一个数。给定一个正整数，找出与其二进制表达式中1的个数相同且大小最接近的那两个数（一个略大，一个略小）。</p>
|
||||
|
||||
<p> <strong>示例1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> 输入</strong>：num = 2（或者0b10）
|
||||
<strong> 输出</strong>：[4, 1] 或者（[0b100, 0b1]）
|
||||
</pre>
|
||||
|
||||
<p> <strong>示例2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong> 输入</strong>：num = 1
|
||||
<strong> 输出</strong>：[2, -1]
|
||||
</pre>
|
||||
|
||||
<p> <strong>提示:</strong></p>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ol>
|
||||
<li><code>num</code>的范围在[1, 2147483647]之间；</li>
|
||||
<li>如果找不到前一个或者后一个满足条件的正数，那么输出 -1。</li>
|
||||
<li><code>num</code> 的范围在[1, 2147483647]之间；</li>
|
||||
<li>如果找不到前一个或者后一个满足条件的正数，那么输出 -1。</li>
|
||||
</ol>
|
||||
|
||||
@@ -1,51 +1,51 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的非负整数数组 <code>nums</code> 。对于 <code>nums</code> 中每一个整数，你必须找到对应元素的 <strong>第二大</strong> 整数。</p>
|
||||
|
||||
<p>如果 <code>nums[j]</code> 满足以下条件，那么我们称它为 <code>nums[i]</code> 的 <strong>第二大</strong> 整数：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>j > i</code></li>
|
||||
<li><code>nums[j] > nums[i]</code></li>
|
||||
<li>恰好存在 <strong>一个</strong> <code>k</code> 满足 <code>i < k < j</code> 且 <code>nums[k] > nums[i]</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>如果不存在 <code>nums[j]</code> ，那么第二大整数为 <code>-1</code> 。</p>
|
||||
|
||||
<ul>
|
||||
<li>比方说，数组 <code>[1, 2, 4, 3]</code> 中，<code>1</code> 的第二大整数是 <code>4</code> ，<code>2</code> 的第二大整数是 <code>3</code> ，<code>3</code> 和 <code>4</code> 的第二大整数是 <code>-1</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回一个整数数组<em> </em><code>answer</code> ，其中<em> </em><code>answer[i]</code>是<em> </em><code>nums[i]</code> 的第二大整数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [2,4,0,9,6]
|
||||
<b>输出：</b>[9,6,6,-1,-1]
|
||||
<strong>解释：</strong>
|
||||
下标为 0 处：2 的右边，4 是大于 2 的第一个整数，9 是第二个大于 2 的整数。
|
||||
下标为 1 处：4 的右边，9 是大于 4 的第一个整数，6 是第二个大于 4 的整数。
|
||||
下标为 2 处：0 的右边，9 是大于 0 的第一个整数，6 是第二个大于 0 的整数。
|
||||
下标为 3 处：右边不存在大于 9 的整数，所以第二大整数为 -1 。
|
||||
下标为 4 处：右边不存在大于 6 的整数，所以第二大整数为 -1 。
|
||||
所以我们返回 [9,6,6,-1,-1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,3]
|
||||
<b>输出：</b>[-1,-1]
|
||||
<strong>解释：</strong>
|
||||
由于每个数右边都没有更大的数，所以我们返回 [-1,-1] 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的非负整数数组 <code>nums</code> 。对于 <code>nums</code> 中每一个整数，你必须找到对应元素的 <strong>第二大</strong> 整数。</p>
|
||||
|
||||
<p>如果 <code>nums[j]</code> 满足以下条件，那么我们称它为 <code>nums[i]</code> 的 <strong>第二大</strong> 整数：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>j > i</code></li>
|
||||
<li><code>nums[j] > nums[i]</code></li>
|
||||
<li>恰好存在 <strong>一个</strong> <code>k</code> 满足 <code>i < k < j</code> 且 <code>nums[k] > nums[i]</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>如果不存在 <code>nums[j]</code> ，那么第二大整数为 <code>-1</code> 。</p>
|
||||
|
||||
<ul>
|
||||
<li>比方说，数组 <code>[1, 2, 4, 3]</code> 中，<code>1</code> 的第二大整数是 <code>4</code> ，<code>2</code> 的第二大整数是 <code>3</code> ，<code>3</code> 和 <code>4</code> 的第二大整数是 <code>-1</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回一个整数数组<em> </em><code>answer</code> ，其中<em> </em><code>answer[i]</code>是<em> </em><code>nums[i]</code> 的第二大整数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>nums = [2,4,0,9,6]
|
||||
<b>输出：</b>[9,6,6,-1,-1]
|
||||
<strong>解释：</strong>
|
||||
下标为 0 处：2 的右边，4 是大于 2 的第一个整数，9 是第二个大于 2 的整数。
|
||||
下标为 1 处：4 的右边，9 是大于 4 的第一个整数，6 是第二个大于 4 的整数。
|
||||
下标为 2 处：0 的右边，9 是大于 0 的第一个整数，6 是第二个大于 0 的整数。
|
||||
下标为 3 处：右边不存在大于 9 的整数，所以第二大整数为 -1 。
|
||||
下标为 4 处：右边不存在大于 6 的整数，所以第二大整数为 -1 。
|
||||
所以我们返回 [9,6,6,-1,-1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,3]
|
||||
<b>输出：</b>[-1,-1]
|
||||
<strong>解释：</strong>
|
||||
由于每个数右边都没有更大的数，所以我们返回 [-1,-1] 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2021/11/03/failing1-grid.jpg" style="height: 500px; width: 499px;" /></p>
|
||||
<p><img alt="" src="https://pic.leetcode.cn/1729566253-aneDag-image.png" style="height: 500px; width: 499px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>matrix = [[2,1,3],[6,5,4],[7,8,9]]
|
||||
@@ -16,7 +16,7 @@
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2021/11/03/failing2-grid.jpg" style="height: 365px; width: 164px;" /></p>
|
||||
<p><img alt="" src="https://pic.leetcode.cn/1729566282-dtXwRd-image.png" style="height: 365px; width: 164px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>matrix = [[-19,57],[-40,-5]]
|
||||
|
||||
@@ -1,48 +1,48 @@
|
||||
<p>给你一个长度为 <code>n</code> 的整数数组 <code>rolls</code> 和一个整数 <code>k</code> 。你扔一个 <code>k</code> 面的骰子 <code>n</code> 次，骰子的每个面分别是 <code>1</code> 到 <code>k</code> ，其中第 <code>i</code> 次扔得到的数字是 <code>rolls[i]</code> 。</p>
|
||||
|
||||
<p>请你返回 <strong>无法</strong> 从 <code>rolls</code> 中得到的 <strong>最短</strong> 骰子子序列的长度。</p>
|
||||
|
||||
<p>扔一个 <code>k</code> 面的骰子 <code>len</code> 次得到的是一个长度为 <code>len</code> 的 <strong>骰子子序列</strong> 。</p>
|
||||
|
||||
<p><strong>注意</strong> ，子序列只需要保持在原数组中的顺序，不需要连续。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>rolls = [4,2,1,2,3,3,2,4,1], k = 4
|
||||
<b>输出：</b>3
|
||||
<b>解释：</b>所有长度为 1 的骰子子序列 [1] ，[2] ，[3] ，[4] 都可以从原数组中得到。
|
||||
所有长度为 2 的骰子子序列 [1, 1] ，[1, 2] ，... ，[4, 4] 都可以从原数组中得到。
|
||||
子序列 [1, 4, 2] 无法从原数组中得到，所以我们返回 3 。
|
||||
还有别的子序列也无法从原数组中得到。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>rolls = [1,1,2,2], k = 2
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>所有长度为 1 的子序列 [1] ，[2] 都可以从原数组中得到。
|
||||
子序列 [2, 1] 无法从原数组中得到，所以我们返回 2 。
|
||||
还有别的子序列也无法从原数组中得到，但 [2, 1] 是最短的子序列。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>rolls = [1,1,3,2,2,2,3,3], k = 4
|
||||
<b>输出：</b>1
|
||||
<b>解释：</b>子序列 [4] 无法从原数组中得到，所以我们返回 1 。
|
||||
还有别的子序列也无法从原数组中得到，但 [4] 是最短的子序列。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == rolls.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= rolls[i] <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
<p>给你一个长度为 <code>n</code> 的整数数组 <code>rolls</code> 和一个整数 <code>k</code> 。你扔一个 <code>k</code> 面的骰子 <code>n</code> 次，骰子的每个面分别是 <code>1</code> 到 <code>k</code> ，其中第 <code>i</code> 次扔得到的数字是 <code>rolls[i]</code> 。</p>
|
||||
|
||||
<p>请你返回 <strong>无法</strong> 从 <code>rolls</code> 中得到的 <strong>最短</strong> 骰子子序列的长度。</p>
|
||||
|
||||
<p>扔一个 <code>k</code> 面的骰子 <code>len</code> 次得到的是一个长度为 <code>len</code> 的 <strong>骰子子序列</strong> 。</p>
|
||||
|
||||
<p><strong>注意</strong> ，子序列只需要保持在原数组中的顺序，不需要连续。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>rolls = [4,2,1,2,3,3,2,4,1], k = 4
|
||||
<b>输出：</b>3
|
||||
<b>解释：</b>所有长度为 1 的骰子子序列 [1] ，[2] ，[3] ，[4] 都可以从原数组中得到。
|
||||
所有长度为 2 的骰子子序列 [1, 1] ，[1, 2] ，... ，[4, 4] 都可以从原数组中得到。
|
||||
子序列 [1, 4, 2] 无法从原数组中得到，所以我们返回 3 。
|
||||
还有别的子序列也无法从原数组中得到。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>rolls = [1,1,2,2], k = 2
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>所有长度为 1 的子序列 [1] ，[2] 都可以从原数组中得到。
|
||||
子序列 [2, 1] 无法从原数组中得到，所以我们返回 2 。
|
||||
还有别的子序列也无法从原数组中得到，但 [2, 1] 是最短的子序列。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>rolls = [1,1,3,2,2,2,3,3], k = 4
|
||||
<b>输出：</b>1
|
||||
<b>解释：</b>子序列 [4] 无法从原数组中得到，所以我们返回 1 。
|
||||
还有别的子序列也无法从原数组中得到，但 [4] 是最短的子序列。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == rolls.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= rolls[i] <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>返回 <code>s</code> 字典序最小的子序列，该子序列包含 <code>s</code> 的所有不同字符，且只包含一次。</p>
|
||||
<p>返回 <code>s</code> 字典序最小的<span data-keyword="subsequence-array">子序列</span>，该子序列包含 <code>s</code> 的所有不同字符，且只包含一次。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,34 +1,34 @@
|
||||
<p>给定一个字符串 <code>s</code><strong> </strong>和一个字符串 <code>t</code> ，计算在 <code>s</code> 的子序列中 <code>t</code> 出现的个数。</p>
|
||||
<p>给定一个字符串 <code>s</code> 和一个字符串 <code>t</code> ，计算在 <code>s</code> 的子序列中 <code>t</code> 出现的个数。</p>
|
||||
|
||||
<p>字符串的一个 <strong>子序列</strong> 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，<code>"ACE"</code> 是 <code>"ABCDE"</code> 的一个子序列，而 <code>"AEC"</code> 不是）</p>
|
||||
<p>字符串的一个 <strong>子序列</strong> 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，<code>"ACE"</code> 是 <code>"ABCDE"</code> 的一个子序列，而 <code>"AEC"</code> 不是）</p>
|
||||
|
||||
<p>题目数据保证答案符合 32 位带符号整数范围。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "rabbbit", t = "rabbit"<code>
|
||||
<strong>输出</strong></code><strong>：</strong><code>3
|
||||
</code><strong>解释：</strong>
|
||||
如下图所示, 有 3 种可以从 s 中得到 <code>"rabbit" 的方案</code>。
|
||||
<code><strong><u>rabb</u></strong>b<strong><u>it</u></strong></code>
|
||||
<code><strong><u>ra</u></strong>b<strong><u>bbit</u></strong></code>
|
||||
<code><strong><u>rab</u></strong>b<strong><u>bit</u></strong></code></pre>
|
||||
<strong>输入：</strong>s = "rabbbit", t = "rabbit"
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>
|
||||
如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
|
||||
<strong><u>rabb</u></strong>b<strong><u>it</u></strong>
|
||||
<strong><u>ra</u></strong>b<strong><u>bbit</u></strong>
|
||||
<strong><u>rab</u></strong>b<strong><u>bit</u></strong></pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "babgbag", t = "bag"
|
||||
<code><strong>输出</strong></code><strong>：</strong><code>5
|
||||
</code><strong>解释：</strong>
|
||||
如下图所示, 有 5 种可以从 s 中得到 <code>"bag" 的方案</code>。
|
||||
<code><strong><u>ba</u></strong>b<u><strong>g</strong></u>bag</code>
|
||||
<code><strong><u>ba</u></strong>bgba<strong><u>g</u></strong></code>
|
||||
<code><u><strong>b</strong></u>abgb<strong><u>ag</u></strong></code>
|
||||
<code>ba<u><strong>b</strong></u>gb<u><strong>ag</strong></u></code>
|
||||
<code>babg<strong><u>bag</u></strong></code>
|
||||
<strong>输出：</strong>5
|
||||
<strong>解释：</strong>
|
||||
如下图所示, 有 5 种可以从 s 中得到 "bag" 的方案。
|
||||
<strong><u>ba</u></strong>b<u><strong>g</strong></u>bag
|
||||
<strong><u>ba</u></strong>bgba<strong><u>g</u></strong>
|
||||
<u><strong>b</strong></u>abgb<strong><u>ag</u></strong>
|
||||
ba<u><strong>b</strong></u>gb<u><strong>ag</strong></u>
|
||||
babg<strong><u>bag</u></strong>
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
@@ -42,4 +42,6 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><meta charset="UTF-8" />注意：本题与主站 115 题相同： <a href="https://leetcode-cn.com/problems/distinct-subsequences/">https://leetcode-cn.com/problems/distinct-subsequences/</a></p>
|
||||
<p><meta charset="UTF-8" />注意：本题与主站 115 题相同： <a href="https://leetcode-cn.com/problems/distinct-subsequences/">https://leetcode-cn.com/problems/distinct-subsequences/</a></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -1,50 +1,50 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始长度为 <strong>偶数</strong> 的整数数组 <code>nums</code> 。</p>
|
||||
|
||||
<p>只要 <code>nums</code> <strong>不是</strong> 空数组，你就重复执行以下步骤：</p>
|
||||
|
||||
<ul>
|
||||
<li>找到 <code>nums</code> 中的最小值，并删除它。</li>
|
||||
<li>找到 <code>nums</code> 中的最大值，并删除它。</li>
|
||||
<li>计算删除两数的平均值。</li>
|
||||
</ul>
|
||||
|
||||
<p>两数 <code>a</code> 和 <code>b</code> 的 <strong>平均值</strong> 为 <code>(a + b) / 2</code> 。</p>
|
||||
|
||||
<ul>
|
||||
<li>比方说，<code>2</code> 和 <code>3</code> 的平均值是 <code>(2 + 3) / 2 = 2.5</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回上述过程能得到的 <strong>不同</strong> 平均值的数目。</p>
|
||||
|
||||
<p><strong>注意</strong> ，如果最小值或者最大值有重复元素，可以删除任意一个。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [4,1,4,0,3,5]
|
||||
<b>输出：</b>2
|
||||
<strong>解释：</strong>
|
||||
1. 删除 0 和 5 ，平均值是 (0 + 5) / 2 = 2.5 ，现在 nums = [4,1,4,3] 。
|
||||
2. 删除 1 和 4 ，平均值是 (1 + 4) / 2 = 2.5 ，现在 nums = [4,3] 。
|
||||
3. 删除 3 和 4 ，平均值是 (3 + 4) / 2 = 3.5 。
|
||||
2.5 ，2.5 和 3.5 之中总共有 2 个不同的数，我们返回 2 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1,100]
|
||||
<b>输出：</b>1
|
||||
<strong>解释：</strong>
|
||||
删除 1 和 100 后只有一个平均值，所以我们返回 1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 100</code></li>
|
||||
<li><code>nums.length</code> 是偶数。</li>
|
||||
<li><code>0 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
<p>给你一个下标从 <strong>0</strong> 开始长度为 <strong>偶数</strong> 的整数数组 <code>nums</code> 。</p>
|
||||
|
||||
<p>只要 <code>nums</code> <strong>不是</strong> 空数组，你就重复执行以下步骤：</p>
|
||||
|
||||
<ul>
|
||||
<li>找到 <code>nums</code> 中的最小值，并删除它。</li>
|
||||
<li>找到 <code>nums</code> 中的最大值，并删除它。</li>
|
||||
<li>计算删除两数的平均值。</li>
|
||||
</ul>
|
||||
|
||||
<p>两数 <code>a</code> 和 <code>b</code> 的 <strong>平均值</strong> 为 <code>(a + b) / 2</code> 。</p>
|
||||
|
||||
<ul>
|
||||
<li>比方说，<code>2</code> 和 <code>3</code> 的平均值是 <code>(2 + 3) / 2 = 2.5</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回上述过程能得到的 <strong>不同</strong> 平均值的数目。</p>
|
||||
|
||||
<p><strong>注意</strong> ，如果最小值或者最大值有重复元素，可以删除任意一个。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [4,1,4,0,3,5]
|
||||
<b>输出：</b>2
|
||||
<strong>解释：</strong>
|
||||
1. 删除 0 和 5 ，平均值是 (0 + 5) / 2 = 2.5 ，现在 nums = [4,1,4,3] 。
|
||||
2. 删除 1 和 4 ，平均值是 (1 + 4) / 2 = 2.5 ，现在 nums = [4,3] 。
|
||||
3. 删除 3 和 4 ，平均值是 (3 + 4) / 2 = 3.5 。
|
||||
2.5 ，2.5 和 3.5 之中总共有 2 个不同的数，我们返回 2 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1,100]
|
||||
<b>输出：</b>1
|
||||
<strong>解释：</strong>
|
||||
删除 1 和 100 后只有一个平均值，所以我们返回 1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 100</code></li>
|
||||
<li><code>nums.length</code> 是偶数。</li>
|
||||
<li><code>0 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
<p>一个机器人位于一个<meta charset="UTF-8" /> <code>m x n</code> 网格的左上角 （起始点在下图中标记为 “Start” ）。</p>
|
||||
<p>给定一个 <code>m x n</code> 的整数数组 <code>grid</code>。一个机器人初始位于 <strong>左上角</strong>（即 <code>grid[0][0]</code>）。机器人尝试移动到 <strong>右下角</strong>（即 <code>grid[m - 1][n - 1]</code>）。机器人每次只能向下或者向右移动一步。</p>
|
||||
|
||||
<p>机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。</p>
|
||||
<p>网格中的障碍物和空位置分别用 <code>1</code> 和 <code>0</code> 来表示。机器人的移动路径中不能包含 <strong>任何</strong> 有障碍物的方格。</p>
|
||||
|
||||
<p>现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？</p>
|
||||
<p>返回机器人能够到达右下角的不同路径数量。</p>
|
||||
|
||||
<p>网格中的障碍物和空位置分别用 <code>1</code> 和 <code>0</code> 来表示。</p>
|
||||
<p>测试用例保证答案小于等于 <code>2 * 10<sup>9</sup></code>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>在两条独立的水平线上按给定的顺序写下 <code>nums1</code> 和 <code>nums2</code> 中的整数。</p>
|
||||
|
||||
<p>现在，可以绘制一些连接两个数字 <code>nums1[i]</code> 和 <code>nums2[j]</code> 的直线，这些直线需要同时满足满足：</p>
|
||||
<p>现在，可以绘制一些连接两个数字 <code>nums1[i]</code> 和 <code>nums2[j]</code> 的直线，这些直线需要同时满足：</p>
|
||||
|
||||
<ul>
|
||||
<li> <code>nums1[i] == nums2[j]</code></li>
|
||||
|
||||
@@ -1,40 +1,40 @@
|
||||
<p>给你一个字符串 <code>s</code> 和一个 <strong>正</strong> 整数 <code>k</code> 。</p>
|
||||
|
||||
<p>从字符串 <code>s</code> 中选出一组满足下述条件且 <strong>不重叠</strong> 的子字符串：</p>
|
||||
|
||||
<ul>
|
||||
<li>每个子字符串的长度 <strong>至少</strong> 为 <code>k</code> 。</li>
|
||||
<li>每个子字符串是一个 <strong>回文串</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回最优方案中能选择的子字符串的 <strong>最大</strong> 数目。</p>
|
||||
|
||||
<p><strong>子字符串</strong> 是字符串中一个连续的字符序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1 ：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "abaccdbbd", k = 3
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>可以选择 s = "<em><strong>aba</strong></em>cc<em><strong>dbbd</strong></em>" 中斜体加粗的子字符串。"aba" 和 "dbbd" 都是回文，且长度至少为 k = 3 。
|
||||
可以证明，无法选出两个以上的有效子字符串。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2 ：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "adbcda", k = 2
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>字符串中不存在长度至少为 2 的回文子字符串。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= s.length <= 2000</code></li>
|
||||
<li><code>s</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
<p>给你一个字符串 <code>s</code> 和一个 <strong>正</strong> 整数 <code>k</code> 。</p>
|
||||
|
||||
<p>从字符串 <code>s</code> 中选出一组满足下述条件且 <strong>不重叠</strong> 的子字符串：</p>
|
||||
|
||||
<ul>
|
||||
<li>每个子字符串的长度 <strong>至少</strong> 为 <code>k</code> 。</li>
|
||||
<li>每个子字符串是一个 <strong>回文串</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回最优方案中能选择的子字符串的 <strong>最大</strong> 数目。</p>
|
||||
|
||||
<p><strong>子字符串</strong> 是字符串中一个连续的字符序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1 ：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "abaccdbbd", k = 3
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>可以选择 s = "<em><strong>aba</strong></em>cc<em><strong>dbbd</strong></em>" 中斜体加粗的子字符串。"aba" 和 "dbbd" 都是回文，且长度至少为 k = 3 。
|
||||
可以证明，无法选出两个以上的有效子字符串。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2 ：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "adbcda", k = 2
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>字符串中不存在长度至少为 2 的回文子字符串。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= s.length <= 2000</code></li>
|
||||
<li><code>s</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,39 +1,39 @@
|
||||
<p>给你一个 <strong>不包含</strong> 任何零的整数数组 <code>nums</code> ，找出自身与对应的负数都在数组中存在的最大正整数 <code>k</code> 。</p>
|
||||
|
||||
<p>返回正整数<em> </em><code>k</code> ，如果不存在这样的整数，返回 <code>-1</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-1,2,-3,3]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>3 是数组中唯一一个满足题目要求的 k 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-1,10,6,7,-7,1]
|
||||
<strong>输出：</strong>7
|
||||
<strong>解释：</strong>数组中存在 1 和 7 对应的负数，7 的值更大。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-10,8,6,7,-2,-3]
|
||||
<strong>输出：</strong>-1
|
||||
<strong>解释：</strong>不存在满足题目要求的 k ，返回 -1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>-1000 <= nums[i] <= 1000</code></li>
|
||||
<li><code>nums[i] != 0</code></li>
|
||||
</ul>
|
||||
<p>给你一个 <strong>不包含</strong> 任何零的整数数组 <code>nums</code> ，找出自身与对应的负数都在数组中存在的最大正整数 <code>k</code> 。</p>
|
||||
|
||||
<p>返回正整数<em> </em><code>k</code> ，如果不存在这样的整数，返回 <code>-1</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-1,2,-3,3]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>3 是数组中唯一一个满足题目要求的 k 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-1,10,6,7,-7,1]
|
||||
<strong>输出：</strong>7
|
||||
<strong>解释：</strong>数组中存在 1 和 7 对应的负数，7 的值更大。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-10,8,6,7,-2,-3]
|
||||
<strong>输出：</strong>-1
|
||||
<strong>解释：</strong>不存在满足题目要求的 k ，返回 -1 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>-1000 <= nums[i] <= 1000</code></li>
|
||||
<li><code>nums[i] != 0</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
<p>给你四个整数：<code>n</code> 、<code>a</code> 、<code>b</code> 、<code>c</code> ，请你设计一个算法来找出第 <code>n</code> 个丑数。</p>
|
||||
<p>丑数是可以被 <code>a</code> <strong>或</strong> <code>b</code> <strong>或</strong> <code>c</code> 整除的 <strong>正整数</strong> 。</p>
|
||||
|
||||
<p>丑数是可以被 <code>a</code> <strong>或</strong> <code>b</code> <strong>或</strong> <code>c</code> 整除的 <strong>正整数</strong> 。</p>
|
||||
<p>给你四个整数：<code>n</code> 、<code>a</code> 、<code>b</code> 、<code>c</code> ，请你设计一个算法来找出第 <code>n</code> 个丑数。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -27,19 +27,12 @@
|
||||
<strong>解释：</strong>丑数序列为 2, 4, 6, 8, 10, 11, 12, 13... 其中第 5 个是 10。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1000000000, a = 2, b = 217983653, c = 336916467
|
||||
<strong>输出：</strong>1999999984
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n, a, b, c <= 10^9</code></li>
|
||||
<li><code>1 <= a * b * c <= 10^18</code></li>
|
||||
<li>本题结果在 <code>[1, 2 * 10^9]</code> 的范围内</li>
|
||||
<li><code>1 <= n, a, b, c <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= a * b * c <= 10<sup>18</sup></code></li>
|
||||
<li>本题结果在 <code>[1, 2 * 10<sup>9</sup>]</code> 的范围内</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p><strong>丑数 </strong>就是只包含质因数 <code>2</code>、<code>3</code> 和 <code>5</code> 的正整数。</p>
|
||||
<p><strong>丑数 </strong>就是只包含质因数 <code>2</code>、<code>3</code> 和 <code>5</code> 的 <em>正 </em>整数。</p>
|
||||
|
||||
<p>给你一个整数 <code>n</code> ，请你判断 <code>n</code> 是否为 <strong>丑数</strong> 。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
@@ -16,7 +16,7 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>1 没有质因数，因此它的全部质因数是 {2, 3, 5} 的空集。习惯上将其视作第一个丑数。</pre>
|
||||
<strong>解释：</strong>1 没有质因数。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
|
||||
@@ -1,51 +1,51 @@
|
||||
<p>给你一个正整数 <code>n</code> ，表示总共有 <code>n</code> 个城市，城市从 <code>1</code> 到 <code>n</code> 编号。给你一个二维数组 <code>roads</code> ，其中 <code>roads[i] = [a<sub>i</sub>, b<sub>i</sub>, distance<sub>i</sub>]</code> 表示城市 <code>a<sub>i</sub></code> 和 <code>b<sub>i</sub></code> 之间有一条 <strong>双向</strong> 道路，道路距离为 <code>distance<sub>i</sub></code> 。城市构成的图不一定是连通的。</p>
|
||||
|
||||
<p>两个城市之间一条路径的 <strong>分数</strong> 定义为这条路径中道路的 <strong>最小</strong> 距离。</p>
|
||||
|
||||
<p><span class="text-only" data-eleid="20" style="white-space: pre;">城市</span><span class="text-only text-font-italic" data-eleid="21" style="white-space: pre;"> </span><code><span class="text-only" data-eleid="22" style="white-space: pre;">1</span></code><span class="text-only text-font-italic" data-eleid="23" style="white-space: pre;"> </span><span class="text-only" data-eleid="24" style="white-space: pre;">和城市</span><span class="text-only text-font-italic" data-eleid="25" style="white-space: pre;"> </span><span class="text-only" data-eleid="26" style="white-space: pre;"><code>n</code> 之间的所有路径的 </span><strong><span class="text-only" data-eleid="27" style="white-space: pre;">最小</span></strong><span class="text-only" data-eleid="28" style="white-space: pre;"> 分数。</span></p>
|
||||
|
||||
<p><b>注意：</b></p>
|
||||
|
||||
<ul>
|
||||
<li>一条路径指的是两个城市之间的道路序列。</li>
|
||||
<li>一条路径可以 <strong>多次</strong> 包含同一条道路，你也可以沿着路径多次到达城市 <code>1</code> 和城市 <code>n</code> 。</li>
|
||||
<li>测试数据保证城市 <code>1</code> 和城市<code>n</code> 之间 <strong>至少</strong> 有一条路径。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/10/12/graph11.png" style="width: 190px; height: 231px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 4, roads = [[1,2,9],[2,3,6],[2,4,5],[1,4,7]]
|
||||
<b>输出：</b>5
|
||||
<b>解释：</b>城市 1 到城市 4 的路径中，分数最小的一条为：1 -> 2 -> 4 。这条路径的分数是 min(9,5) = 5 。
|
||||
不存在分数更小的路径。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/10/12/graph22.png" style="width: 190px; height: 231px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 4, roads = [[1,2,2],[1,3,4],[3,4,7]]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>城市 1 到城市 4 分数最小的路径是：1 -> 2 -> 1 -> 3 -> 4 。这条路径的分数是 min(2,2,4,7) = 2 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= roads.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>roads[i].length == 3</code></li>
|
||||
<li><code>1 <= a<sub>i</sub>, b<sub>i</sub> <= n</code></li>
|
||||
<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
|
||||
<li><code>1 <= distance<sub>i</sub> <= 10<sup>4</sup></code></li>
|
||||
<li>不会有重复的边。</li>
|
||||
<li>城市 <code>1</code> 和城市 <code>n</code> 之间至少有一条路径。</li>
|
||||
</ul>
|
||||
<p>给你一个正整数 <code>n</code> ，表示总共有 <code>n</code> 个城市，城市从 <code>1</code> 到 <code>n</code> 编号。给你一个二维数组 <code>roads</code> ，其中 <code>roads[i] = [a<sub>i</sub>, b<sub>i</sub>, distance<sub>i</sub>]</code> 表示城市 <code>a<sub>i</sub></code> 和 <code>b<sub>i</sub></code> 之间有一条 <strong>双向</strong> 道路，道路距离为 <code>distance<sub>i</sub></code> 。城市构成的图不一定是连通的。</p>
|
||||
|
||||
<p>两个城市之间一条路径的 <strong>分数</strong> 定义为这条路径中道路的 <strong>最小</strong> 距离。</p>
|
||||
|
||||
<p><span class="text-only" data-eleid="20" style="white-space: pre;">城市</span><span class="text-only text-font-italic" data-eleid="21" style="white-space: pre;"> </span><code><span class="text-only" data-eleid="22" style="white-space: pre;">1</span></code><span class="text-only text-font-italic" data-eleid="23" style="white-space: pre;"> </span><span class="text-only" data-eleid="24" style="white-space: pre;">和城市</span><span class="text-only text-font-italic" data-eleid="25" style="white-space: pre;"> </span><span class="text-only" data-eleid="26" style="white-space: pre;"><code>n</code> 之间的所有路径的 </span><strong><span class="text-only" data-eleid="27" style="white-space: pre;">最小</span></strong><span class="text-only" data-eleid="28" style="white-space: pre;"> 分数。</span></p>
|
||||
|
||||
<p><b>注意：</b></p>
|
||||
|
||||
<ul>
|
||||
<li>一条路径指的是两个城市之间的道路序列。</li>
|
||||
<li>一条路径可以 <strong>多次</strong> 包含同一条道路，你也可以沿着路径多次到达城市 <code>1</code> 和城市 <code>n</code> 。</li>
|
||||
<li>测试数据保证城市 <code>1</code> 和城市<code>n</code> 之间 <strong>至少</strong> 有一条路径。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/10/12/graph11.png" style="width: 190px; height: 231px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 4, roads = [[1,2,9],[2,3,6],[2,4,5],[1,4,7]]
|
||||
<b>输出：</b>5
|
||||
<b>解释：</b>城市 1 到城市 4 的路径中，分数最小的一条为：1 -> 2 -> 4 。这条路径的分数是 min(9,5) = 5 。
|
||||
不存在分数更小的路径。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/10/12/graph22.png" style="width: 190px; height: 231px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>n = 4, roads = [[1,2,2],[1,3,4],[3,4,7]]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>城市 1 到城市 4 分数最小的路径是：1 -> 2 -> 1 -> 3 -> 4 。这条路径的分数是 min(2,2,4,7) = 2 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= roads.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>roads[i].length == 3</code></li>
|
||||
<li><code>1 <= a<sub>i</sub>, b<sub>i</sub> <= n</code></li>
|
||||
<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
|
||||
<li><code>1 <= distance<sub>i</sub> <= 10<sup>4</sup></code></li>
|
||||
<li>不会有重复的边。</li>
|
||||
<li>城市 <code>1</code> 和城市 <code>n</code> 之间至少有一条路径。</li>
|
||||
</ul>
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
<li><code>"c"</code> 在 <code>s</code> 中的位置与在 <code>t</code> 中的位置之差的绝对值。</li>
|
||||
</ul>
|
||||
|
||||
<p>即，<code>s</code> 和 <code>t</code> 的排列差等于 <code>|0 - 1| + |2 - 2| + |1 - 0| = 2</code>。</p>
|
||||
<p>即，<code>s</code> 和 <code>t</code> 的排列差等于 <code>|0 - 1| + |1 - 0| + |2 - 2| = 2</code>。</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>给定两个数组 <code>nums1</code> 和 <code>nums2</code> ，返回 <em>它们的交集</em> 。输出结果中的每个元素一定是 <strong>唯一</strong> 的。我们可以 <strong>不考虑输出结果的顺序</strong> 。</p>
|
||||
<p>给定两个数组 <code>nums1</code> 和 <code>nums2</code> ，返回 <em>它们的 <span data-keyword="array-intersection">交集</span></em> 。输出结果中的每个元素一定是 <strong>唯一</strong> 的。我们可以 <strong>不考虑输出结果的顺序</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,38 +1,38 @@
|
||||
<p>在 <strong>X轴</strong> 上有一些奖品。给你一个整数数组 <code>prizePositions</code> ，它按照 <strong>非递减</strong> 顺序排列，其中 <code>prizePositions[i]</code> 是第 <code>i</code> 件奖品的位置。数轴上一个位置可能会有多件奖品。再给你一个整数 <code>k</code> 。</p>
|
||||
|
||||
<p>你可以选择两个端点为整数的线段。每个线段的长度都必须是 <code>k</code> 。你可以获得位置在任一线段上的所有奖品（包括线段的两个端点）。注意，两个线段可能会有相交。</p>
|
||||
|
||||
<ul>
|
||||
<li>比方说 <code>k = 2</code> ，你可以选择线段 <code>[1, 3]</code> 和 <code>[2, 4]</code> ，你可以获得满足 <code>1 <= prizePositions[i] <= 3</code> 或者 <code>2 <= prizePositions[i] <= 4</code> 的所有奖品 i 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回在选择两个最优线段的前提下，可以获得的 <strong>最多</strong> 奖品数目。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>prizePositions = [1,1,2,2,3,3,5], k = 2
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>这个例子中，你可以选择线段 [1, 3] 和 [3, 5] ，获得 7 个奖品。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>prizePositions = [1,2,3,4], k = 0
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>这个例子中，一个选择是选择线段 <code>[3, 3]</code> 和 <code>[4, 4] ，获得 2 个奖品。</code>
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prizePositions.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= prizePositions[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= k <= 10<sup>9</sup> </code></li>
|
||||
<li><code>prizePositions</code> 有序非递减。</li>
|
||||
</ul>
|
||||
<p>在 <strong>X轴</strong> 上有一些奖品。给你一个整数数组 <code>prizePositions</code> ，它按照 <strong>非递减</strong> 顺序排列，其中 <code>prizePositions[i]</code> 是第 <code>i</code> 件奖品的位置。数轴上一个位置可能会有多件奖品。再给你一个整数 <code>k</code> 。</p>
|
||||
|
||||
<p>你可以同时选择两个端点为整数的线段。每个线段的长度都必须是 <code>k</code> 。你可以获得位置在任一线段上的所有奖品（包括线段的两个端点）。注意，两个线段可能会有相交。</p>
|
||||
|
||||
<ul>
|
||||
<li>比方说 <code>k = 2</code> ，你可以选择线段 <code>[1, 3]</code> 和 <code>[2, 4]</code> ，你可以获得满足 <code>1 <= prizePositions[i] <= 3</code> 或者 <code>2 <= prizePositions[i] <= 4</code> 的所有奖品 i 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回在选择两个最优线段的前提下，可以获得的 <strong>最多</strong> 奖品数目。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>prizePositions = [1,1,2,2,3,3,5], k = 2
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>这个例子中，你可以选择线段 [1, 3] 和 [3, 5] ，获得 7 个奖品。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>prizePositions = [1,2,3,4], k = 0
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>这个例子中，一个选择是选择线段 <code>[3, 3]</code> 和 <code>[4, 4]</code> ，获得 2 个奖品。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prizePositions.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= prizePositions[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= k <= 10<sup>9</sup> </code></li>
|
||||
<li><code>prizePositions</code> 有序非递减。</li>
|
||||
</ul>
|
||||
|
||||
@@ -7,21 +7,21 @@
|
||||
<p>你所设计的解决方案必须只使用常量级的额外空间。</p>
|
||||
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numbers = [<strong><em>2</em></strong>,<strong><em>7</em></strong>,11,15], target = 9
|
||||
<strong>输出：</strong>[1,2]
|
||||
<strong>解释：</strong>2 与 7 之和等于目标数 9 。因此 index<sub>1</sub> = 1, index<sub>2</sub> = 2 。返回 [1, 2] 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numbers = [<strong><em>2</em></strong>,3,<strong><em>4</em></strong>], target = 6
|
||||
<strong>输出：</strong>[1,3]
|
||||
<strong>解释：</strong>2 与 4 之和等于目标数 6 。因此 index<sub>1</sub> = 1, index<sub>2</sub> = 3 。返回 [1, 3] 。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numbers = [<strong><em>-1</em></strong>,<strong><em>0</em></strong>], target = -1
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code>，请你在该数组中找出 <strong>和为目标值 </strong><em><code>target</code></em> 的那 <strong>两个</strong> 整数，并返回它们的数组下标。</p>
|
||||
|
||||
<p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p>
|
||||
<p>你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。</p>
|
||||
|
||||
<p>你可以按任意顺序返回答案。</p>
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例1：</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://pic.leetcode-cn.com/1626420025-fZfzMX-image.png" style="width: 302px; " /></p>
|
||||
|
||||
@@ -13,14 +13,14 @@
|
||||
<strong>输出：</strong>[7,8,0,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例2：</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [2,4,3], l2 = [5,6,4]
|
||||
<strong>输出：</strong>[8,0,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例3：</strong></p>
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [0], l2 = [0]
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
<p>给你两个 <strong>非空</strong> 的链表，表示两个非负的整数。它们每位数字都是按照 <strong>逆序</strong> 的方式存储的，并且每个节点只能存储 <strong>一位</strong> 数字。</p>
|
||||
<p>给你两个 <strong>非空</strong> 的链表，表示两个非负的整数。它们每位数字都是按照 <strong>逆序</strong> 的方式存储的，并且每个节点只能存储 <strong>一位</strong> 数字。</p>
|
||||
|
||||
<p>请你将两个数相加，并以相同形式返回一个表示和的链表。</p>
|
||||
|
||||
<p>你可以假设除了数字 0 之外，这两个数都不会以 0 开头。</p>
|
||||
<p>你可以假设除了数字 0 之外，这两个数都不会以 0 开头。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/01/02/addtwonumber1.jpg" style="width: 483px; height: 342px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [2,4,3], l2 = [5,6,4]
|
||||
@@ -14,26 +14,26 @@
|
||||
<strong>解释：</strong>342 + 465 = 807.
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [0], l2 = [0]
|
||||
<strong>输出：</strong>[0]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
|
||||
<strong>输出：</strong>[8,9,9,9,0,0,0,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>每个链表中的节点数在范围 <code>[1, 100]</code> 内</li>
|
||||
<li><code>0 <= Node.val <= 9</code></li>
|
||||
<li><code>0 <= Node.val <= 9</code></li>
|
||||
<li>题目数据保证列表表示的数字不含前导零</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,33 +1,33 @@
|
||||
<p>如果一个整数 <code>n</code> 在 <code>b</code> 进制下（<code>b</code> 为 <code>2</code> 到 <code>n - 2</code> 之间的所有整数）对应的字符串 <strong>全部</strong> 都是 <strong>回文的</strong> ，那么我们称这个数 <code>n</code> 是 <strong>严格回文</strong> 的。</p>
|
||||
|
||||
<p>给你一个整数 <code>n</code> ，如果 <code>n</code> 是 <strong>严格回文</strong> 的，请返回 <code>true</code> ，否则返回<em> </em><code>false</code> 。</p>
|
||||
|
||||
<p>如果一个字符串从前往后读和从后往前读完全相同，那么这个字符串是 <strong>回文的</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 9
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>在 2 进制下：9 = 1001 ，是回文的。
|
||||
在 3 进制下：9 = 100 ，不是回文的。
|
||||
所以，9 不是严格回文数字，我们返回 false 。
|
||||
注意在 4, 5, 6 和 7 进制下，n = 9 都不是回文的。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 4
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>我们只考虑 2 进制：4 = 100 ，不是回文的。
|
||||
所以我们返回 false 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>4 <= n <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
<p>如果一个整数 <code>n</code> 在 <code>b</code> 进制下（<code>b</code> 为 <code>2</code> 到 <code>n - 2</code> 之间的所有整数）对应的字符串 <strong>全部</strong> 都是 <strong>回文的</strong> ，那么我们称这个数 <code>n</code> 是 <strong>严格回文</strong> 的。</p>
|
||||
|
||||
<p>给你一个整数 <code>n</code> ，如果 <code>n</code> 是 <strong>严格回文</strong> 的，请返回 <code>true</code> ，否则返回<em> </em><code>false</code> 。</p>
|
||||
|
||||
<p>如果一个字符串从前往后读和从后往前读完全相同，那么这个字符串是 <strong>回文的</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 9
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>在 2 进制下：9 = 1001 ，是回文的。
|
||||
在 3 进制下：9 = 100 ，不是回文的。
|
||||
所以，9 不是严格回文数字，我们返回 false 。
|
||||
注意在 4, 5, 6 和 7 进制下，n = 9 都不是回文的。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 4
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>我们只考虑 2 进制：4 = 100 ，不是回文的。
|
||||
所以我们返回 false 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>4 <= n <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -35,4 +35,5 @@
|
||||
<li><code>1 <= expression.length <= 20</code></li>
|
||||
<li><code>expression</code> 由数字和算符 <code>'+'</code>、<code>'-'</code> 和 <code>'*'</code> 组成。</li>
|
||||
<li>输入表达式中的所有整数值在范围 <code>[0, 99]</code> </li>
|
||||
<li>输入表达式中的所有整数都没有前导 <code>'-'</code> 或 <code>'+'</code> 表示符号。</li>
|
||||
</ul>
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
假如整个 `grid` 区域的外侧均为走廊。请问，不与走廊直接相邻的主题空间的最大面积是多少？如果不存在这样的空间请返回 `0`。
|
||||
|
||||
**示例 1:**
|
||||
**示例 1：**
|
||||
>输入：`grid = ["110","231","221"]`
|
||||
>
|
||||
>输出：`1`
|
||||
@@ -11,7 +11,7 @@
|
||||
>
|
||||
|
||||
|
||||
**示例 2:**
|
||||
**示例 2：**
|
||||
>输入：`grid = ["11111100000","21243101111","21224101221","11111101111"]`
|
||||
>
|
||||
>输出：`3`
|
||||
@@ -23,5 +23,5 @@
|
||||
**提示：**
|
||||
- `1 <= grid.length <= 500`
|
||||
- `1 <= grid[i].length <= 500`
|
||||
- `grid[i][j]` 仅可能是 `"0"～"5"`
|
||||
- `grid[i][j]` 仅可能为 `"0"～"5"`
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> nums = [10,5,2,6], k = 100
|
||||
@@ -11,7 +11,7 @@
|
||||
需要注意的是 [10,5,2] 并不是乘积小于100的子数组。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> nums = [1,2,3], k = 0
|
||||
@@ -19,7 +19,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示: </strong></p>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 3 * 10<sup>4</sup></code></li>
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [10,5,2,6], k = 100
|
||||
<strong>输出：</strong>8
|
||||
<strong>解释：</strong>8 个乘积小于 100 的子数组分别为：[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
|
||||
<strong>解释：</strong>8 个乘积小于 100 的子数组分别为：[10]、[5]、[2]、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
|
||||
需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
|
||||
</pre>
|
||||
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
<p>给你一个整数数组 <code>nums</code> ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。</p>
|
||||
<p>给你一个整数数组 <code>nums</code> ，请你找出数组中乘积最大的非空连续 <span data-keyword="subarray-nonempty">子数组</span>（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。</p>
|
||||
|
||||
<p>测试用例的答案是一个 <strong>32-位</strong> 整数。</p>
|
||||
|
||||
<p><strong>子数组</strong> 是数组的连续子序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong class="example">示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> nums = [2,3,-2,4]
|
||||
@@ -14,7 +12,7 @@
|
||||
<strong>解释:</strong> 子数组 [2,3] 有最大乘积 6。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong class="example">示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> nums = [-2,0,-1]
|
||||
@@ -28,5 +26,5 @@
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>-10 <= nums[i] <= 10</code></li>
|
||||
<li><code>nums</code> 的任何前缀或后缀的乘积都 <strong>保证</strong> 是一个 <strong>32-位</strong> 整数</li>
|
||||
<li><code>nums</code> 的任何子数组的乘积都 <strong>保证</strong> 是一个 <strong>32-位</strong> 整数</li>
|
||||
</ul>
|
||||
|
||||
@@ -11,24 +11,24 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [7,1,5,3,6,4]
|
||||
<strong>输出：</strong>7
|
||||
<strong>解释：</strong>在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
|
||||
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
|
||||
总利润为 4 + 3 = 7 。</pre>
|
||||
<strong>解释：</strong>在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
|
||||
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
|
||||
最大总利润为 4 + 3 = 7 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [1,2,3,4,5]
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
|
||||
总利润为 4 。</pre>
|
||||
<strong>解释：</strong>在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
|
||||
最大总利润为 4 。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [7,6,4,3,1]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。</pre>
|
||||
<strong>解释：</strong>在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -10,23 +10,40 @@
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>tickets = [2,3,2], k = 2
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>
|
||||
- 第一轮，队伍中的每个人都买到一张票，队伍变为 [1, 2, 1] 。
|
||||
- 第二轮，队伍中的每个都又都买到一张票，队伍变为 [0, 1, 0] 。
|
||||
位置 2 的人成功买到 2 张票，用掉 3 + 3 = 6 秒。
|
||||
</pre>
|
||||
<div class="example-block">
|
||||
<p><strong>输入：</strong>tickets = [2,3,2], k = 2</p>
|
||||
|
||||
<p><strong>输出：</strong>6</p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>队伍一开始为 [2,3,2]，第 k 个人以下划线标识。</li>
|
||||
<li>在最前面的人买完票后，队伍在第 1 秒变成 [3,<u>2</u>,1]。</li>
|
||||
<li>继续这个过程，队伍在第 2 秒变为[<u>2</u>,1,2]。</li>
|
||||
<li>继续这个过程，队伍在第 3 秒变为[1,2,<u>1</u>]。</li>
|
||||
<li>继续这个过程，队伍在第 4 秒变为[2,<u>1</u>]。</li>
|
||||
<li>继续这个过程，队伍在第 5 秒变为[<u>1</u>,1]。</li>
|
||||
<li>继续这个过程，队伍在第 6 秒变为[1]。第 k 个人完成买票，所以返回 6。</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>tickets = [5,1,1,1], k = 0
|
||||
<strong>输出：</strong>8
|
||||
<strong>解释：</strong>
|
||||
- 第一轮，队伍中的每个人都买到一张票，队伍变为 [4, 0, 0, 0] 。
|
||||
- 接下来的 4 轮，只有位置 0 的人在买票。
|
||||
位置 0 的人成功买到 5 张票，用掉 4 + 1 + 1 + 1 + 1 = 8 秒。
|
||||
</pre>
|
||||
<div class="example-block">
|
||||
<p><strong>输入：</strong>tickets = [5,1,1,1], k = 0</p>
|
||||
|
||||
<p><strong>输出：</strong>8</p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>队伍一开始为 [<u>5</u>,1,1,1]，第 k 个人以下划线标识。</li>
|
||||
<li>在最前面的人买完票后，队伍在第 1 秒变成 [1,1,1,<u>4</u>]。</li>
|
||||
<li>继续这个过程 3 秒，队伍在第 4 秒变为[<u>4</u>]。</li>
|
||||
<li>继续这个过程 4 秒，队伍在第 8 秒变为[]。第 k 个人完成买票，所以返回 8。</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -60,7 +60,7 @@ emitter.emit("firstEvent", [4, 5, 6]); // [], 没有订阅者
|
||||
<b>输入：
|
||||
</b>actions = ["EventEmitter", "subscribe", "subscribe", "unsubscribe", "emit"],
|
||||
values = [[], ["firstEvent", "x => x + 1"], ["firstEvent", "x => x + 2"], [0], ["firstEvent", [5]]]
|
||||
<b>输出：</b>[[],["subscribed"],["emitted",["1,2,3"]],["unsubscribed",0],["emitted",[7]]]
|
||||
<b>输出：</b>[[],["subscribed"],["subscribed"],["unsubscribed",0],["emitted",[7]]]
|
||||
<b>解释：</b>
|
||||
const emitter = new EventEmitter();
|
||||
const sub1 = emitter.subscribe("firstEvent", x => x + 1);
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>给定一个二叉搜索树的根节点 <code>root</code> ，和一个整数 <code>k</code> ，请你设计一个算法查找其中第 <code>k</code><strong> </strong>个最小元素（从 1 开始计数）。</p>
|
||||
<p>给定一个二叉搜索树的根节点 <code>root</code> ，和一个整数 <code>k</code> ，请你设计一个算法查找其中第 <code>k</code><strong> </strong>小的元素（从 1 开始计数）。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg" style="width: 212px; height: 301px;" />
|
||||
@@ -16,18 +16,18 @@
|
||||
<strong>输出：</strong>3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中的节点数为 <code>n</code> 。</li>
|
||||
<li><code>1 <= k <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= k <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 <code>k</code> 小的值，你将如何优化算法？</p>
|
||||
@@ -4,12 +4,12 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>root = [2,1,3]
|
||||
<strong>输出: </strong>[[2,1,3],[2,3,1]]
|
||||
解释: 数组 [2,1,3]、[2,3,1] 均可以通过从左向右遍历元素插入树中形成以下二叉搜索树
|
||||
<strong>输入：</strong>root = [2,1,3]
|
||||
<strong>输出：</strong>[[2,1,3],[2,3,1]]
|
||||
<strong>解释：</strong>数组 [2,1,3]、[2,3,1] 均可以通过从左向右遍历元素插入树中形成以下二叉搜索树
|
||||
2
|
||||
/ \
|
||||
1 3
|
||||
@@ -17,11 +17,11 @@
|
||||
|
||||
<p><meta charset="UTF-8" /></p>
|
||||
|
||||
<p><strong>示例</strong><strong> 2:</strong></p>
|
||||
<p><strong>示例 </strong><strong>2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>root = [4,1,null,null,3,2]
|
||||
<strong>输出: </strong>[[4,1,3,2]]
|
||||
<strong>输入：</strong>root = [4,1,null,null,3,2]
|
||||
<strong>输出：</strong>[[4,1,3,2]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
@@ -30,7 +30,7 @@
|
||||
|
||||
<ul>
|
||||
<li>二叉搜索树中的节点数在<meta charset="UTF-8" /> <code>[0, 1000]</code> 的范围内</li>
|
||||
<li><code>1 <= 节点值 <= 10^6</code></li>
|
||||
<li><code>1 <= 节点值 <= 10<sup>6</sup></code></li>
|
||||
<li>
|
||||
<p>用例保证符合要求的数组数量不超过 <code>5000</code></p>
|
||||
</li>
|
||||
|
||||
@@ -1,47 +1,47 @@
|
||||
<p>给你一个 <strong>二叉搜索树</strong> 的根节点 <code>root</code> ，和一个由正整数组成、长度为 <code>n</code> 的数组 <code>queries</code> 。</p>
|
||||
|
||||
<p>请你找出一个长度为 <code>n</code> 的 <strong>二维</strong> 答案数组 <code>answer</code> ，其中 <code>answer[i] = [min<sub>i</sub>, max<sub>i</sub>]</code> ：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>min<sub>i</sub></code> 是树中小于等于 <code>queries[i]</code> 的 <strong>最大值</strong> 。如果不存在这样的值，则使用 <code>-1</code> 代替。</li>
|
||||
<li><code>max<sub>i</sub></code> 是树中大于等于 <code>queries[i]</code> 的 <strong>最小值</strong> 。如果不存在这样的值，则使用 <code>-1</code> 代替。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回数组 <code>answer</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1 ：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/09/28/bstreeedrawioo.png" style="width: 261px; height: 281px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [6,2,13,1,4,9,15,null,null,null,null,null,null,14], queries = [2,5,16]
|
||||
<strong>输出：</strong>[[2,2],[4,6],[15,-1]]
|
||||
<strong>解释：</strong>按下面的描述找出并返回查询的答案：
|
||||
- 树中小于等于 2 的最大值是 2 ，且大于等于 2 的最小值也是 2 。所以第一个查询的答案是 [2,2] 。
|
||||
- 树中小于等于 5 的最大值是 4 ，且大于等于 5 的最小值是 6 。所以第二个查询的答案是 [4,6] 。
|
||||
- 树中小于等于 16 的最大值是 15 ，且大于等于 16 的最小值不存在。所以第三个查询的答案是 [15,-1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2 ：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/09/28/bstttreee.png" style="width: 101px; height: 121px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [4,null,9], queries = [3]
|
||||
<strong>输出：</strong>[[-1,4]]
|
||||
<strong>解释：</strong>树中不存在小于等于 3 的最大值，且大于等于 3 的最小值是 4 。所以查询的答案是 [-1,4] 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数目在范围 <code>[2, 10<sup>5</sup>]</code> 内</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li><code>n == queries.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= queries[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
<p>给你一个 <strong>二叉搜索树</strong> 的根节点 <code>root</code> ，和一个由正整数组成、长度为 <code>n</code> 的数组 <code>queries</code> 。</p>
|
||||
|
||||
<p>请你找出一个长度为 <code>n</code> 的 <strong>二维</strong> 答案数组 <code>answer</code> ，其中 <code>answer[i] = [min<sub>i</sub>, max<sub>i</sub>]</code> ：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>min<sub>i</sub></code> 是树中小于等于 <code>queries[i]</code> 的 <strong>最大值</strong> 。如果不存在这样的值，则使用 <code>-1</code> 代替。</li>
|
||||
<li><code>max<sub>i</sub></code> 是树中大于等于 <code>queries[i]</code> 的 <strong>最小值</strong> 。如果不存在这样的值，则使用 <code>-1</code> 代替。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回数组 <code>answer</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1 ：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/09/28/bstreeedrawioo.png" style="width: 261px; height: 281px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [6,2,13,1,4,9,15,null,null,null,null,null,null,14], queries = [2,5,16]
|
||||
<strong>输出：</strong>[[2,2],[4,6],[15,-1]]
|
||||
<strong>解释：</strong>按下面的描述找出并返回查询的答案：
|
||||
- 树中小于等于 2 的最大值是 2 ，且大于等于 2 的最小值也是 2 。所以第一个查询的答案是 [2,2] 。
|
||||
- 树中小于等于 5 的最大值是 4 ，且大于等于 5 的最小值是 6 。所以第二个查询的答案是 [4,6] 。
|
||||
- 树中小于等于 16 的最大值是 15 ，且大于等于 16 的最小值不存在。所以第三个查询的答案是 [15,-1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2 ：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/09/28/bstttreee.png" style="width: 101px; height: 121px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [4,null,9], queries = [3]
|
||||
<strong>输出：</strong>[[-1,4]]
|
||||
<strong>解释：</strong>树中不存在小于等于 3 的最大值，且大于等于 3 的最小值是 4 。所以查询的答案是 [-1,4] 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数目在范围 <code>[2, 10<sup>5</sup>]</code> 内</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li><code>n == queries.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= queries[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,29 +1,31 @@
|
||||
<p>给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。</p>
|
||||
|
||||
<p><a href="https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin" target="_blank">百度百科</a>中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（<strong>一个节点也可以是它自己的祖先</strong>）。”</p>
|
||||
<p><a href="https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin" target="_blank">百度百科</a>中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（<strong>一个节点也可以是它自己的祖先</strong>）。”</p>
|
||||
|
||||
<p>例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/binarysearchtree_improved.png"></p>
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/binarysearchtree_improved.png" /></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
|
||||
<strong>输出:</strong> 6
|
||||
<strong>解释: </strong>节点 <code>2 </code>和节点 <code>8 </code>的最近公共祖先是 <code>6。</code>
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>节点 <code>2 </code>和节点 <code>8 </code>的最近公共祖先是 <code>6。</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
|
||||
<strong>输出:</strong> 2
|
||||
<strong>解释: </strong>节点 <code>2</code> 和节点 <code>4</code> 的最近公共祖先是 <code>2</code>, 因为根据定义最近公共祖先节点可以为节点本身。</pre>
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>节点 <code>2</code> 和节点 <code>4</code> 的最近公共祖先是 <code>2</code>, 因为根据定义最近公共祖先节点可以为节点本身。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>说明:</strong></p>
|
||||
<p><strong>说明：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>所有节点的值都是唯一的。</li>
|
||||
|
||||
@@ -21,13 +21,13 @@
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png" style="width: 189px; height: 178px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入</strong>
|
||||
<strong>输入：</strong>
|
||||
inputs = ["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
|
||||
inputs = [[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
|
||||
<strong>输出</strong>
|
||||
<strong>输出：</strong>
|
||||
[null, 3, 7, true, 9, true, 15, true, 20, false]
|
||||
|
||||
<strong>解释</strong>
|
||||
<strong>解释：</strong>
|
||||
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
|
||||
bSTIterator.next(); // 返回 3
|
||||
bSTIterator.next(); // 返回 7
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>给定一个二叉树（具有根结点 <code>root</code>）， 一个目标结点 <code>target</code> ，和一个整数值 <code>k</code> 。</p>
|
||||
<p>给定一个二叉树（具有根结点 <code>root</code>）， 一个目标结点 <code>target</code> ，和一个整数值 <code>k</code> ，返回到目标结点 <code>target</code> 距离为 <code>k</code> 的所有结点的值的数组。</p>
|
||||
|
||||
<p>返回到目标结点 <code>target</code> 距离为 <code>k</code> 的所有结点的值的列表。 答案可以以 <strong>任何顺序</strong> 返回。</p>
|
||||
<p>答案可以以 <strong>任何顺序</strong> 返回。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,45 +1,45 @@
|
||||
<p>给你一棵二叉树的根节点 <code>root</code> 和一个正整数 <code>k</code> 。</p>
|
||||
|
||||
<p>树中的 <strong>层和</strong> 是指 <strong>同一层</strong> 上节点值的总和。</p>
|
||||
|
||||
<p>返回树中第 <code>k</code> 大的层和（不一定不同）。如果树少于 <code>k</code> 层，则返回 <code>-1</code> 。</p>
|
||||
|
||||
<p><strong>注意</strong>，如果两个节点与根节点的距离相同，则认为它们在同一层。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/14/binaryytreeedrawio-2.png" style="width: 301px; height: 284px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [5,8,9,2,1,3,7,4,6], k = 2
|
||||
<strong>输出：</strong>13
|
||||
<strong>解释：</strong>树中每一层的层和分别是：
|
||||
- Level 1: 5
|
||||
- Level 2: 8 + 9 = 17
|
||||
- Level 3: 2 + 1 + 3 + 7 = 13
|
||||
- Level 4: 4 + 6 = 10
|
||||
第 2 大的层和等于 13 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/14/treedrawio-3.png" style="width: 181px; height: 181px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,null,3], k = 1
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>最大的层和是 3 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中的节点数为 <code>n</code></li>
|
||||
<li><code>2 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li><code>1 <= k <= n</code></li>
|
||||
</ul>
|
||||
<p>给你一棵二叉树的根节点 <code>root</code> 和一个正整数 <code>k</code> 。</p>
|
||||
|
||||
<p>树中的 <strong>层和</strong> 是指 <strong>同一层</strong> 上节点值的总和。</p>
|
||||
|
||||
<p>返回树中第 <code>k</code> 大的层和（不一定不同）。如果树少于 <code>k</code> 层，则返回 <code>-1</code> 。</p>
|
||||
|
||||
<p><strong>注意</strong>，如果两个节点与根节点的距离相同，则认为它们在同一层。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/14/binaryytreeedrawio-2.png" style="width: 301px; height: 284px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [5,8,9,2,1,3,7,4,6], k = 2
|
||||
<strong>输出：</strong>13
|
||||
<strong>解释：</strong>树中每一层的层和分别是：
|
||||
- Level 1: 5
|
||||
- Level 2: 8 + 9 = 17
|
||||
- Level 3: 2 + 1 + 3 + 7 = 13
|
||||
- Level 4: 4 + 6 = 10
|
||||
第 2 大的层和等于 13 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/14/treedrawio-3.png" style="width: 181px; height: 181px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,null,3], k = 1
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>最大的层和是 3 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中的节点数为 <code>n</code></li>
|
||||
<li><code>2 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li><code>1 <= k <= n</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,null,0,0,1]
|
||||
@@ -16,7 +16,7 @@
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_2.png" style="width:450px" />
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,0,1,0,0,0,1]
|
||||
@@ -26,7 +26,7 @@
|
||||
<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_1.png" style="width:450px" />
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,1,0,1,1,0,1,0]
|
||||
@@ -38,7 +38,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>二叉树的节点个数的范围是 <code>[1,200]</code></li>
|
||||
|
||||
@@ -1,42 +1,33 @@
|
||||
<p>「力扣嘉年华」的中心广场放置了一个巨型的二叉树形状的装饰树。每个节点上均有一盏灯和三个开关。节点值为 <code>0</code> 表示灯处于「关闭」状态，节点值为 <code>1</code> 表示灯处于「开启」状态。每个节点上的三个开关各自功能如下：</p>
|
||||
「力扣嘉年华」的中心广场放置了一个巨型的二叉树形状的装饰树。每个节点上均有一盏灯和三个开关。节点值为 `0` 表示灯处于「关闭」状态，节点值为 `1` 表示灯处于「开启」状态。每个节点上的三个开关各自功能如下：
|
||||
- 开关 `1`：切换当前节点的灯的状态；
|
||||
- 开关 `2`：切换 **以当前节点为根** 的子树中，所有节点上的灯的状态，；
|
||||
- 开关 `3`：切换 **当前节点及其左右子节点**（若存在的话） 上的灯的状态；
|
||||
|
||||
<ul>
|
||||
<li>开关 <code>1</code>：切换当前节点的灯的状态；</li>
|
||||
<li>开关 <code>2</code>：切换 <strong>以当前节点为根</strong> 的子树中，所有节点上的灯的状态；</li>
|
||||
<li>开关 <code>3</code>：切换 <strong>当前节点及其左右子节点</strong>（若存在的话） 上的灯的状态；</li>
|
||||
</ul>
|
||||
给定该装饰的初始状态 `root`，请返回最少需要操作多少次开关，可以关闭所有节点的灯。
|
||||
|
||||
<p>给定该装饰的初始状态 <code>root</code>，请返回最少需要操作多少次开关，可以关闭所有节点的灯。</p>
|
||||
**示例 1：**
|
||||
>输入：`root = [1,1,0,null,null,null,1]`
|
||||
>
|
||||
>输出：`2`
|
||||
>
|
||||
>解释：以下是最佳的方案之一，如图所示
|
||||
{:width="300px"}
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
**示例 2：**
|
||||
>输入：`root = [1,1,1,1,null,null,1]`
|
||||
>
|
||||
>输出：`1`
|
||||
>
|
||||
>解释：以下是最佳的方案，如图所示
|
||||
{:width="300px"}
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,1,0,null,null,null,1]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>以下是最佳的方案之一，如图所示
|
||||
<img alt="" src="https://pic.leetcode-cn.com/1629357030-GSbzpY-b71b95bf405e3b223e00b2820a062ba4.gif" style="width: 300px; height: 225px;" />
|
||||
</pre>
|
||||
**示例 3：**
|
||||
>输入：`root = [0,null,0]`
|
||||
>
|
||||
>输出：`0`
|
||||
>
|
||||
>解释：无需操作开关，当前所有节点上的灯均已关闭
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,1,1,1,null,null,1]
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>以下是最佳的方案，如图所示
|
||||
<img alt="" src="https://pic.leetcode-cn.com/1629356950-HZsKZC-a4091b6448a0089b4d9e8f0390ff9ac6.gif" style="width: 300px; height: 225px;" />
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [0,null,0]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>无需操作开关，当前所有节点上的灯均已关闭
|
||||
</pre>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= 节点个数 <= 10^5</code></li>
|
||||
<li><code>0 <= Node.val <= 1</code></li>
|
||||
</ul>
|
||||
**提示：**
|
||||
- `1 <= 节点个数 <= 10^5`
|
||||
- `0 <= Node.val <= 1`
|
||||
@@ -1,51 +1,56 @@
|
||||
<p>给你二叉树的根节点 <code>root</code> ，返回它节点值的 <strong>前序</strong><em> </em>遍历。</p>
|
||||
<p>给你二叉树的根节点 <code>root</code> ，返回它节点值的 <strong>前序</strong><em> </em>遍历。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 202px; height: 324px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2,3]
|
||||
<strong>输出：</strong>[1,2,3]
|
||||
</pre>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<div class="example-block">
|
||||
<p><strong>输入：</strong><span class="example-io">root = [1,null,2,3]</span></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
<p><strong>输出：</strong><span class="example-io">[1,2,3]</span></p>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png" style="width: 200px; height: 264px;" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg" style="width: 202px; height: 202px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<p><strong>示例 5：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg" style="width: 202px; height: 202px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>
|
||||
|
||||
<p> </p>
|
||||
<p><span class="example-io"><b>输出：</b>[1,2,4,5,6,7,3,8,9]</span></p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/tree_2.png" style="width: 350px; height: 286px;" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = []</span></p>
|
||||
|
||||
<p><span class="example-io"><b>输出：</b>[]</span></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 4：</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>输入：</strong><span class="example-io">root = [1]</span></p>
|
||||
|
||||
<p><span class="example-io"><b>输出：</b>[1]</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[0, 100]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>递归算法很简单，你可以通过迭代算法完成吗？</p>
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2021/02/14/tree.jpg" style="width: 270px; " /></p>
|
||||
|
||||
@@ -11,14 +11,14 @@
|
||||
<strong>输出:</strong> [1,3,4]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,null,3]
|
||||
<strong>输出:</strong> [1,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> []
|
||||
@@ -27,7 +27,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>二叉树的节点个数的范围是 <code>[0,100]</code></li>
|
||||
|
||||
@@ -1,35 +1,52 @@
|
||||
<p>给定一个二叉树的 <strong>根节点</strong> <code>root</code>，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2021/02/14/tree.jpg" style="width: 270px; " /></p>
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = [1,2,3,null,5,null,4]</span></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,2,3,null,5,null,4]
|
||||
<strong>输出:</strong> [1,3,4]
|
||||
</pre>
|
||||
<p><strong>输出：</strong><span class="example-io">[1,3,4]</span></p>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,null,3]
|
||||
<strong>输出:</strong> [1,3]
|
||||
</pre>
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/11/24/tmpd5jn43fs-1.png" style="width: 400px; height: 207px;" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> []
|
||||
<strong>输出:</strong> []
|
||||
</pre>
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = [1,2,3,4,null,null,null,5]</span></p>
|
||||
|
||||
<p> </p>
|
||||
<p><span class="example-io"><b>输出：</b>[1,3,4,5]</span></p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/11/24/tmpkpe40xeh-1.png" style="width: 400px; height: 214px;" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>输入：</strong><span class="example-io">root = [1,null,3]</span></p>
|
||||
|
||||
<p><strong>输出：</strong><span class="example-io">[1,3]</span></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 4：</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = []</span></p>
|
||||
|
||||
<p><strong>输出：</strong><span class="example-io">[]</span></p>
|
||||
|
||||
<p> </p>
|
||||
</div>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>二叉树的节点个数的范围是 <code>[0,100]</code></li>
|
||||
<li><meta charset="UTF-8" /><code>-100 <= Node.val <= 100</code> </li>
|
||||
<li><meta charset="UTF-8" /><code>-100 <= Node.val <= 100</code> </li>
|
||||
</ul>
|
||||
|
||||
@@ -2,26 +2,45 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/pre1.jpg" style="width: 127px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2,3]
|
||||
<strong>输出：</strong>[3,2,1]
|
||||
</pre>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = [1,null,2,3]</span></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
<p><span class="example-io"><b>输出：</b>[3,2,1]</span></p>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png" style="width: 200px; height: 264px;" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>
|
||||
|
||||
<p><span class="example-io"><b>输出：</b>[4,6,7,5,2,9,8,3,1]</span></p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/tree_2.png" style="width: 350px; height: 286px;" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = []</span></p>
|
||||
|
||||
<p><span class="example-io"><b>输出：</b>[]</span></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 4：</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>root = [1]</span></p>
|
||||
|
||||
<p><span class="example-io"><b>输出：</b>[1]</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
<p>给你二叉树的根结点 <code>root</code> ，请你设计算法计算二叉树的<em> </em><strong>垂序遍历</strong> 序列。</p>
|
||||
|
||||
<p>对位于 <code>(row, col)</code> 的每个结点而言，其左右子结点分别位于 <code>(row + 1, col - 1)</code> 和 <code>(row + 1, col + 1)</code> 。树的根结点位于 <code>(0, 0)</code> 。</p>
|
||||
<p>对位于 <code>(row, col)</code> 的每个结点而言，其左右子结点分别位于 <code>(row + 1, col - 1)</code> 和 <code>(row + 1, col + 1)</code> 。树的根结点位于 <code>(0, 0)</code> 。</p>
|
||||
|
||||
<p>二叉树的 <strong>垂序遍历</strong> 从最左边的列开始直到最右边的列结束，按列索引每一列上的所有结点，形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点，则按结点的值从小到大进行排序。</p>
|
||||
|
||||
<p>返回二叉树的 <strong>垂序遍历</strong> 序列。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/29/vtree1.jpg" style="width: 431px; height: 304px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,9,20,null,null,15,7]
|
||||
@@ -19,7 +19,7 @@
|
||||
列 1 ：只有结点 20 在此列中。
|
||||
列 2 ：只有结点 7 在此列中。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/29/vtree2.jpg" style="width: 512px; height: 304px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,4,5,6,7]
|
||||
@@ -34,7 +34,7 @@
|
||||
列 2 ：只有结点 7 在此列中。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/29/vtree3.jpg" style="width: 512px; height: 304px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,4,6,5,7]
|
||||
@@ -43,11 +43,11 @@
|
||||
这个示例实际上与示例 2 完全相同，只是结点 5 和 6 在树中的位置发生了交换。
|
||||
因为 5 和 6 的位置仍然相同，所以答案保持不变，仍然按值从小到大排序。</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中结点数目总数在范围 <code>[1, 1000]</code> 内</li>
|
||||
<li><code>0 <= Node.val <= 1000</code></li>
|
||||
<li><code>0 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,47 +1,47 @@
|
||||
<p>给你一棵二叉树的根 <code>root</code> ，请你将每个节点的值替换成该节点的所有 <strong>堂兄弟节点值的和 </strong>。</p>
|
||||
|
||||
<p>如果两个节点在树中有相同的深度且它们的父节点不同，那么它们互为 <strong>堂兄弟</strong> 。</p>
|
||||
|
||||
<p>请你返回修改值之后，树的根<em> </em><code>root</code><em> </em>。</p>
|
||||
|
||||
<p><strong>注意</strong>，一个节点的深度指的是从树根节点到这个节点经过的边数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/01/11/example11.png" style="width: 571px; height: 151px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>root = [5,4,9,1,10,null,7]
|
||||
<b>输出：</b>[0,0,0,7,7,null,11]
|
||||
<b>解释：</b>上图展示了初始的二叉树和修改每个节点的值之后的二叉树。
|
||||
- 值为 5 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 4 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 9 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 1 的节点有一个堂兄弟，值为 7 ，所以值修改为 7 。
|
||||
- 值为 10 的节点有一个堂兄弟，值为 7 ，所以值修改为 7 。
|
||||
- 值为 7 的节点有两个堂兄弟，值分别为 1 和 10 ，所以值修改为 11 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/01/11/diagram33.png" style="width: 481px; height: 91px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>root = [3,1,2]
|
||||
<b>输出：</b>[0,0,0]
|
||||
<b>解释：</b>上图展示了初始的二叉树和修改每个节点的值之后的二叉树。
|
||||
- 值为 3 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 1 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 2 的节点没有堂兄弟，所以值修改为 0 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目的范围是 <code>[1, 10<sup>5</sup>]</code> 。</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
<p>给你一棵二叉树的根 <code>root</code> ，请你将每个节点的值替换成该节点的所有 <strong>堂兄弟节点值的和 </strong>。</p>
|
||||
|
||||
<p>如果两个节点在树中有相同的深度且它们的父节点不同，那么它们互为 <strong>堂兄弟</strong> 。</p>
|
||||
|
||||
<p>请你返回修改值之后，树的根<em> </em><code>root</code><em> </em>。</p>
|
||||
|
||||
<p><strong>注意</strong>，一个节点的深度指的是从树根节点到这个节点经过的边数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/01/11/example11.png" style="width: 571px; height: 151px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>root = [5,4,9,1,10,null,7]
|
||||
<b>输出：</b>[0,0,0,7,7,null,11]
|
||||
<b>解释：</b>上图展示了初始的二叉树和修改每个节点的值之后的二叉树。
|
||||
- 值为 5 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 4 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 9 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 1 的节点有一个堂兄弟，值为 7 ，所以值修改为 7 。
|
||||
- 值为 10 的节点有一个堂兄弟，值为 7 ，所以值修改为 7 。
|
||||
- 值为 7 的节点有两个堂兄弟，值分别为 1 和 10 ，所以值修改为 11 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/01/11/diagram33.png" style="width: 481px; height: 91px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>root = [3,1,2]
|
||||
<b>输出：</b>[0,0,0]
|
||||
<b>解释：</b>上图展示了初始的二叉树和修改每个节点的值之后的二叉树。
|
||||
- 值为 3 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 1 的节点没有堂兄弟，所以值修改为 0 。
|
||||
- 值为 2 的节点没有堂兄弟，所以值修改为 0 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目的范围是 <code>[1, 10<sup>5</sup>]</code> 。</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -2,9 +2,9 @@
|
||||
|
||||
<p>请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。</p>
|
||||
|
||||
<p><strong>提示: </strong>输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 <a href="/faq/#binary-tree">LeetCode 序列化二叉树的格式</a>。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。</p>
|
||||
<p><strong>提示: </strong>输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 <a href="https://support.leetcode.cn/hc/kb/article/1567641/">LeetCode 序列化二叉树的格式</a>。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/serdeser.jpg" style="width: 442px; height: 324px;" />
|
||||
@@ -34,11 +34,11 @@
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中结点数在范围 <code>[0, 10<sup>4</sup>]</code> 内</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,30 +1,32 @@
|
||||
<p>给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。</p>
|
||||
|
||||
<p><a href="https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin" target="_blank">百度百科</a>中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（<strong>一个节点也可以是它自己的祖先</strong>）。”</p>
|
||||
<p><a href="https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin" target="_blank">百度百科</a>中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（<strong>一个节点也可以是它自己的祖先</strong>）。”</p>
|
||||
|
||||
<p>例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/15/binarytree.png"></p>
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/15/binarytree.png" /></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
|
||||
<strong>输出:</strong> 3
|
||||
<strong>解释: </strong>节点 <code>5 </code>和节点 <code>1 </code>的最近公共祖先是节点 <code>3。</code>
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>节点 <code>5 </code>和节点 <code>1 </code>的最近公共祖先是节点 <code>3。</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
|
||||
<strong>输出:</strong> 5
|
||||
<strong>解释: </strong>节点 <code>5 </code>和节点 <code>4 </code>的最近公共祖先是节点 <code>5。</code>因为根据定义最近公共祖先节点可以为节点本身。
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
|
||||
<strong>输出：</strong>5
|
||||
<strong>解释：</strong>节点 <code>5 </code>和节点 <code>4 </code>的最近公共祖先是节点 <code>5。</code>因为根据定义最近公共祖先节点可以为节点本身。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>说明:</strong></p>
|
||||
<p><strong>说明：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>所有节点的值都是唯一的。</li>
|
||||
|
||||
@@ -1,38 +1,38 @@
|
||||
<p>给你一个正整数 <code>n</code> ，你需要找到一个下标从 <strong>0</strong> 开始的数组 <code>powers</code> ，它包含 <strong>最少</strong> 数目的 <code>2</code> 的幂，且它们的和为 <code>n</code> 。<code>powers</code> 数组是 <strong>非递减</strong> 顺序的。根据前面描述，构造 <code>powers</code> 数组的方法是唯一的。</p>
|
||||
|
||||
<p>同时给你一个下标从 <strong>0</strong> 开始的二维整数数组 <code>queries</code> ，其中 <code>queries[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> ，其中 <code>queries[i]</code> 表示请你求出满足 <code>left<sub>i</sub> <= j <= right<sub>i</sub></code> 的所有 <code>powers[j]</code> 的乘积。</p>
|
||||
|
||||
<p>请你返回一个数组<em> </em><code>answers</code> ，长度与<em> </em><code>queries</code> 的长度相同，其中<em> </em><code>answers[i]</code>是第<em> </em><code>i</code> 个查询的答案。由于查询的结果可能非常大，请你将每个 <code>answers[i]</code> 都对 <code>10<sup>9</sup> + 7</code> <strong>取余</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 15, queries = [[0,1],[2,2],[0,3]]
|
||||
<b>输出：</b>[2,4,64]
|
||||
<strong>解释：</strong>
|
||||
对于 n = 15 ，得到 powers = [1,2,4,8] 。没法得到元素数目更少的数组。
|
||||
第 1 个查询的答案：powers[0] * powers[1] = 1 * 2 = 2 。
|
||||
第 2 个查询的答案：powers[2] = 4 。
|
||||
第 3 个查询的答案：powers[0] * powers[1] * powers[2] * powers[3] = 1 * 2 * 4 * 8 = 64 。
|
||||
每个答案对 10<sup>9</sup> + 7 得到的结果都相同，所以返回 [2,4,64] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 2, queries = [[0,0]]
|
||||
<b>输出：</b>[2]
|
||||
<strong>解释：</strong>
|
||||
对于 n = 2, powers = [2] 。
|
||||
唯一一个查询的答案是 powers[0] = 2 。答案对 10<sup>9</sup> + 7 取余后结果相同，所以返回 [2] 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= start<sub>i</sub> <= end<sub>i</sub> < powers.length</code></li>
|
||||
</ul>
|
||||
<p>给你一个正整数 <code>n</code> ，你需要找到一个下标从 <strong>0</strong> 开始的数组 <code>powers</code> ，它包含 <strong>最少</strong> 数目的 <code>2</code> 的幂，且它们的和为 <code>n</code> 。<code>powers</code> 数组是 <strong>非递减</strong> 顺序的。根据前面描述，构造 <code>powers</code> 数组的方法是唯一的。</p>
|
||||
|
||||
<p>同时给你一个下标从 <strong>0</strong> 开始的二维整数数组 <code>queries</code> ，其中 <code>queries[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> ，其中 <code>queries[i]</code> 表示请你求出满足 <code>left<sub>i</sub> <= j <= right<sub>i</sub></code> 的所有 <code>powers[j]</code> 的乘积。</p>
|
||||
|
||||
<p>请你返回一个数组<em> </em><code>answers</code> ，长度与<em> </em><code>queries</code> 的长度相同，其中<em> </em><code>answers[i]</code>是第<em> </em><code>i</code> 个查询的答案。由于查询的结果可能非常大，请你将每个 <code>answers[i]</code> 都对 <code>10<sup>9</sup> + 7</code> <strong>取余</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 15, queries = [[0,1],[2,2],[0,3]]
|
||||
<b>输出：</b>[2,4,64]
|
||||
<strong>解释：</strong>
|
||||
对于 n = 15 ，得到 powers = [1,2,4,8] 。没法得到元素数目更少的数组。
|
||||
第 1 个查询的答案：powers[0] * powers[1] = 1 * 2 = 2 。
|
||||
第 2 个查询的答案：powers[2] = 4 。
|
||||
第 3 个查询的答案：powers[0] * powers[1] * powers[2] * powers[3] = 1 * 2 * 4 * 8 = 64 。
|
||||
每个答案对 10<sup>9</sup> + 7 得到的结果都相同，所以返回 [2,4,64] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>n = 2, queries = [[0,0]]
|
||||
<b>输出：</b>[2]
|
||||
<strong>解释：</strong>
|
||||
对于 n = 2, powers = [2] 。
|
||||
唯一一个查询的答案是 powers[0] = 2 。答案对 10<sup>9</sup> + 7 取余后结果相同，所以返回 [2] 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= start<sub>i</sub> <= end<sub>i</sub> < powers.length</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
<p>给你一个 <code>m</code> 行 <code>n</code> 列的二维网格 <code>grid</code> 和一个整数 <code>k</code>。你需要将 <code>grid</code> 迁移 <code>k</code> 次。</p>
|
||||
<p>给你一个 <code>m</code> 行 <code>n</code> 列的二维网格 <code>grid</code> 和一个整数 <code>k</code>。你需要将 <code>grid</code> 迁移 <code>k</code> 次。</p>
|
||||
|
||||
<p>每次「迁移」操作将会引发下述活动：</p>
|
||||
|
||||
<ul>
|
||||
<li>位于 <code>grid[i][j]</code> 的元素将会移动到 <code>grid[i][j + 1]</code>。</li>
|
||||
<li>位于 <code>grid[i][n - 1]</code> 的元素将会移动到 <code>grid[i + 1][0]</code>。</li>
|
||||
<li>位于 <code>grid[m - 1][n - 1]</code> 的元素将会移动到 <code>grid[0][0]</code>。</li>
|
||||
<li>位于 <code>grid[i][j]</code>（<code>j < n - 1</code>）的元素将会移动到 <code>grid[i][j + 1]</code>。</li>
|
||||
<li>位于 <code>grid[i][n - 1]</code> 的元素将会移动到 <code>grid[i + 1][0]</code>。</li>
|
||||
<li>位于 <code>grid[m - 1][n - 1]</code> 的元素将会移动到 <code>grid[0][0]</code>。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回 <code>k</code> 次迁移操作后最终得到的 <strong>二维网格</strong>。</p>
|
||||
<p>请你返回 <code>k</code> 次迁移操作后最终得到的 <strong>二维网格</strong>。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -37,15 +37,15 @@
|
||||
<strong>输出：</strong>[[1,2,3],[4,5,6],[7,8,9]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m <= 50</code></li>
|
||||
<li><code>1 <= n <= 50</code></li>
|
||||
<li><code>-1000 <= grid[i][j] <= 1000</code></li>
|
||||
<li><code>0 <= k <= 100</code></li>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m <= 50</code></li>
|
||||
<li><code>1 <= n <= 50</code></li>
|
||||
<li><code>-1000 <= grid[i][j] <= 1000</code></li>
|
||||
<li><code>0 <= k <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,44 +1,44 @@
|
||||
<p>给你一个二进制字符串 <code>s</code> 。在一秒之中，<strong>所有</strong> 子字符串 <code>"01"</code> <strong>同时</strong> 被替换成 <code>"10"</code> 。这个过程持续进行到没有 <code>"01"</code> 存在。</p>
|
||||
|
||||
<p>请你返回完成这个过程所需要的秒数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "0110101"
|
||||
<b>输出：</b>4
|
||||
<b>解释：</b>
|
||||
一秒后，s 变成 "1011010" 。
|
||||
再过 1 秒后，s 变成 "1101100" 。
|
||||
第三秒过后，s 变成 "1110100" 。
|
||||
第四秒后，s 变成 "1111000" 。
|
||||
此时没有 "01" 存在，整个过程花费 4 秒。
|
||||
所以我们返回 4 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "11100"
|
||||
<b>输出：</b>0
|
||||
<strong>解释：</strong>
|
||||
s 中没有 "01" 存在，整个过程花费 0 秒。
|
||||
所以我们返回 0 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s[i]</code> 要么是 <code>'0'</code> ，要么是 <code>'1'</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<p>你能以 O(n) 的时间复杂度解决这个问题吗？</p>
|
||||
<p>给你一个二进制字符串 <code>s</code> 。在一秒之中，<strong>所有</strong> 子字符串 <code>"01"</code> <strong>同时</strong> 被替换成 <code>"10"</code> 。这个过程持续进行到没有 <code>"01"</code> 存在。</p>
|
||||
|
||||
<p>请你返回完成这个过程所需要的秒数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "0110101"
|
||||
<b>输出：</b>4
|
||||
<b>解释：</b>
|
||||
一秒后，s 变成 "1011010" 。
|
||||
再过 1 秒后，s 变成 "1101100" 。
|
||||
第三秒过后，s 变成 "1110100" 。
|
||||
第四秒后，s 变成 "1111000" 。
|
||||
此时没有 "01" 存在，整个过程花费 4 秒。
|
||||
所以我们返回 4 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>s = "11100"
|
||||
<b>输出：</b>0
|
||||
<strong>解释：</strong>
|
||||
s 中没有 "01" 存在，整个过程花费 0 秒。
|
||||
所以我们返回 0 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s[i]</code> 要么是 <code>'0'</code> ，要么是 <code>'1'</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<p>你能以 O(n) 的时间复杂度解决这个问题吗？</p>
|
||||
|
||||
@@ -4,13 +4,13 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> a = "11", b = "10"
|
||||
<strong>输出:</strong> "101"</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> a = "1010", b = "1011"
|
||||
|
||||
@@ -1,44 +1,23 @@
|
||||
<p>给你一个大小为 <code>rows x cols</code> 的矩阵 <code>mat</code>，其中 <code>mat[i][j]</code> 是 <code>0</code> 或 <code>1</code>，请返回 <strong>矩阵 <em><code>mat</code></em> 中特殊位置的数目</strong> 。</p>
|
||||
<p>给定一个 <code>m x n</code> 的二进制矩阵 <code>mat</code>，返回矩阵 <code>mat</code> 中特殊位置的数量。</p>
|
||||
|
||||
<p><strong>特殊位置</strong> 定义：如果 <code>mat[i][j] == 1</code> 并且第 <code>i</code> 行和第 <code>j</code> 列中的所有其他元素均为 <code>0</code>（行和列的下标均 <strong>从 0 开始</strong> ），则位置 <code>(i, j)</code> 被称为特殊位置。</p>
|
||||
<p>如果位置 <code>(i, j)</code> 满足 <code>mat[i][j] == 1</code> 并且行 <code>i</code> 与列 <code>j</code> 中的所有其他元素都是 <code>0</code>（行和列的下标从 <strong>0 </strong>开始计数），那么它被称为<strong> 特殊 </strong>位置。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>mat = [[1,0,0],
|
||||
[0,0,<strong>1</strong>],
|
||||
[1,0,0]]
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/23/special1.jpg" style="width: 244px; height: 245px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[1,0,0],[0,0,1],[1,0,0]]
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>(1,2) 是一个特殊位置，因为 mat[1][2] == 1 且所处的行和列上所有其他元素都是 0
|
||||
<strong>解释：</strong>位置 (1, 2) 是一个特殊位置，因为 mat[1][2] == 1 且第 1 行和第 2 列的其他所有元素都是 0。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>mat = [[<strong>1</strong>,0,0],
|
||||
[0,<strong>1</strong>,0],
|
||||
[0,0,<strong>1</strong>]]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>(0,0), (1,1) 和 (2,2) 都是特殊位置
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>mat = [[0,0,0,<strong>1</strong>],
|
||||
[<strong>1</strong>,0,0,0],
|
||||
[0,1,1,0],
|
||||
[0,0,0,0]]
|
||||
<strong>输出：</strong>2
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>mat = [[0,0,0,0,0],
|
||||
[<strong>1</strong>,0,0,0,0],
|
||||
[0,<strong>1</strong>,0,0,0],
|
||||
[0,0,<strong>1</strong>,0,0],
|
||||
[0,0,0,1,1]]
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/24/special-grid.jpg" style="width: 244px; height: 245px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>mat = [[1,0,0],[0,1,0],[0,0,1]]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>位置 (0, 0)，(1, 1) 和 (2, 2) 都是特殊位置。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
@@ -46,8 +25,8 @@
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>rows == mat.length</code></li>
|
||||
<li><code>cols == mat[i].length</code></li>
|
||||
<li><code>1 <= rows, cols <= 100</code></li>
|
||||
<li><code>mat[i][j]</code> 是 <code>0</code> 或 <code>1</code></li>
|
||||
<li><code>m == mat.length</code></li>
|
||||
<li><code>n == mat[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 100</code></li>
|
||||
<li><code>mat[i][j]</code> 是 <code>0</code> 或 <code>1</code>。</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,41 +1,41 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的 <code>m x n</code> <strong>二进制</strong> 矩阵 <code>grid</code> 。你可以从一个格子 <code>(row, col)</code> 移动到格子 <code>(row + 1, col)</code> 或者 <code>(row, col + 1)</code> ，前提是前往的格子值为 <code>1</code> 。如果从 <code>(0, 0)</code> 到 <code>(m - 1, n - 1)</code> 没有任何路径，我们称该矩阵是 <strong>不连通</strong> 的。</p>
|
||||
|
||||
<p>你可以翻转 <strong>最多一个</strong> 格子的值（也可以不翻转）。你 <strong>不能翻转</strong> 格子 <code>(0, 0)</code> 和 <code>(m - 1, n - 1)</code> 。</p>
|
||||
|
||||
<p>如果可以使矩阵不连通，请你返回 <code>true</code> ，否则返回<em> </em><code>false</code><em> </em>。</p>
|
||||
|
||||
<p><strong>注意</strong> ，翻转一个格子的值，可以使它的值从 <code>0</code> 变 <code>1</code> ，或从 <code>1</code> 变 <code>0</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/07/yetgrid2drawio.png" style="width: 441px; height: 151px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>grid = [[1,1,1],[1,0,0],[1,1,1]]
|
||||
<strong>输出：</strong>true
|
||||
<b>解释：</b>按照上图所示我们翻转蓝色格子里的值，翻转后从 (0, 0) 到 (2, 2) 没有路径。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/07/yetgrid3drawio.png" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>grid = [[1,1,1],[1,0,1],[1,1,1]]
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>无法翻转至多一个格子，使 (0, 0) 到 (2, 2) 没有路径。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 1000</code></li>
|
||||
<li><code>1 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>grid[0][0] == grid[m - 1][n - 1] == 1</code></li>
|
||||
</ul>
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的 <code>m x n</code> <strong>二进制</strong> 矩阵 <code>grid</code> 。你可以从一个格子 <code>(row, col)</code> 移动到格子 <code>(row + 1, col)</code> 或者 <code>(row, col + 1)</code> ，前提是前往的格子值为 <code>1</code> 。如果从 <code>(0, 0)</code> 到 <code>(m - 1, n - 1)</code> 没有任何路径，我们称该矩阵是 <strong>不连通</strong> 的。</p>
|
||||
|
||||
<p>你可以翻转 <strong>最多一个</strong> 格子的值（也可以不翻转）。你 <strong>不能翻转</strong> 格子 <code>(0, 0)</code> 和 <code>(m - 1, n - 1)</code> 。</p>
|
||||
|
||||
<p>如果可以使矩阵不连通，请你返回 <code>true</code> ，否则返回<em> </em><code>false</code><em> </em>。</p>
|
||||
|
||||
<p><strong>注意</strong> ，翻转一个格子的值，可以使它的值从 <code>0</code> 变 <code>1</code> ，或从 <code>1</code> 变 <code>0</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/07/yetgrid2drawio.png" style="width: 441px; height: 151px;" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>grid = [[1,1,1],[1,0,0],[1,1,1]]
|
||||
<strong>输出：</strong>true
|
||||
<b>解释：</b>按照上图所示我们翻转蓝色格子里的值，翻转后从 (0, 0) 到 (2, 2) 没有路径。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/12/07/yetgrid3drawio.png" /></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>grid = [[1,1,1],[1,0,1],[1,1,1]]
|
||||
<b>输出：</b>false
|
||||
<b>解释：</b>无法翻转至多一个格子，使 (0, 0) 到 (2, 2) 没有路径。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 1000</code></li>
|
||||
<li><code>1 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>grid[0][0] == grid[m - 1][n - 1] == 1</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>给你一个正整数数组 <code>arr</code>（可能存在重复的元素），请你返回可在 <strong>一次交换</strong>（交换两数字 <code>arr[i]</code> 和 <code>arr[j]</code> 的位置）后得到的、按字典序排列小于 <code>arr</code> 的最大排列。</p>
|
||||
<p>给你一个正整数数组 <code>arr</code>（可能存在重复的元素），请你返回可在 <strong>一次交换</strong>（交换两数字 <code>arr[i]</code> 和 <code>arr[j]</code> 的位置）后得到的、按<span data-keyword="lexicographically-smaller-string-alien">字典序</span>排列小于 <code>arr</code> 的最大排列。</p>
|
||||
|
||||
<p>如果无法这么操作，就请返回原数组。</p>
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>record = [9, 7, 5, 4, 6]
|
||||
@@ -12,6 +12,6 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>限制：</strong></p>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<p><code>0 <= record.length <= 50000</code></p>
|
||||
|
||||
@@ -1,43 +1,43 @@
|
||||
<p>给你一个正整数 <code>n</code> 。<code>n</code> 中的每一位数字都会按下述规则分配一个符号：</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>最高有效位</strong> 上的数字分配到 <strong>正</strong> 号。</li>
|
||||
<li>剩余每位上数字的符号都与其相邻数字相反。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回所有数字及其对应符号的和。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 521
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>(+5) + (-2) + (+1) = 4</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 111
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>(+1) + (-1) + (+1) = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 886996
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>(+8) + (-8) + (+6) + (-9) + (+9) + (-6) = 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p>给你一个正整数 <code>n</code> 。<code>n</code> 中的每一位数字都会按下述规则分配一个符号：</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>最高有效位</strong> 上的数字分配到 <strong>正</strong> 号。</li>
|
||||
<li>剩余每位上数字的符号都与其相邻数字相反。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回所有数字及其对应符号的和。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 521
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>(+5) + (-2) + (+1) = 4</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 111
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>(+1) + (-1) + (+1) = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 886996
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>(+8) + (-8) + (+6) + (-9) + (+9) + (-6) = 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>给定三个字符串 <code>s1</code>、<code>s2</code>、<code>s3</code>，请你帮忙验证 <code>s3</code> 是否是由 <code>s1</code> 和 <code>s2</code><em> </em><strong>交错 </strong>组成的。</p>
|
||||
|
||||
<p>两个字符串 <code>s</code> 和 <code>t</code> <strong>交错</strong> 的定义与过程如下，其中每个字符串都会被分割成若干 <strong>非空</strong> 子字符串：</p>
|
||||
<p>两个字符串 <code>s</code> 和 <code>t</code> <strong>交错</strong> 的定义与过程如下，其中每个字符串都会被分割成若干 <strong>非空</strong> <span data-keyword="substring-nonempty">子字符串</span>：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>s = s<sub>1</sub> + s<sub>2</sub> + ... + s<sub>n</sub></code></li>
|
||||
|
||||
@@ -1,56 +1,67 @@
|
||||
<p>给你一个 <code>n x 2</code> 的二维数组 <code>points</code> ，它表示二维平面上的一些点坐标，其中 <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> 。</p>
|
||||
|
||||
<p>我们定义 x 轴的正方向为 <strong>右</strong> （<strong>x 轴递增的方向</strong>），x 轴的负方向为 <strong>左</strong> （<strong>x 轴递减的方向</strong>）。类似的，我们定义 y 轴的正方向为 <strong>上</strong> （<strong>y 轴递增的方向</strong>），y 轴的负方向为 <strong>下</strong> （<strong>y 轴递减的方向</strong>）。</p>
|
||||
<p> </p>
|
||||
|
||||
<p>你需要安排这 <code>n</code> 个人的站位，这 <code>n</code> 个人中包括 liupengsay 和小羊肖恩 。你需要确保每个点处 <strong>恰好</strong> 有 <strong>一个</strong> 人。同时，liupengsay 想跟小羊肖恩单独玩耍，所以 liupengsay 会以 liupengsay<b> </b>的坐标为 <strong>左上角</strong> ，小羊肖恩的坐标为 <strong>右下角</strong> 建立一个矩形的围栏（<strong>注意</strong>，围栏可能 <strong>不</strong> 包含任何区域，也就是说围栏可能是一条线段）。如果围栏的 <strong>内部</strong> 或者 <strong>边缘</strong> 上有任何其他人，liupengsay 都会难过。</p>
|
||||
|
||||
<p>请你在确保 liupengsay <strong>不会</strong> 难过的前提下，返回 liupengsay 和小羊肖恩可以选择的 <strong>点对</strong> 数目。</p>
|
||||
|
||||
<p><b>注意</b>，liupengsay 建立的围栏必须确保 liupengsay 的位置是矩形的左上角，小羊肖恩的位置是矩形的右下角。比方说，以 <code>(1, 1)</code> ，<code>(1, 3)</code> ，<code>(3, 1)</code> 和 <code>(3, 3)</code> 为矩形的四个角，给定下图的两个输入，liupengsay 都不能建立围栏，原因如下：</p>
|
||||
<p>计算点对 <code>(A, B)</code> 的数量，其中</p>
|
||||
|
||||
<ul>
|
||||
<li>图一中，liupengsay 在 <code>(3, 3)</code> 且小羊肖恩在 <code>(1, 1)</code> ，liupengsay 的位置不是左上角且小羊肖恩的位置不是右下角。</li>
|
||||
<li>图二中，liupengsay 在 <code>(1, 3)</code> 且小羊肖恩在 <code>(1, 1)</code> ，小羊肖恩的位置不是在围栏的右下角。</li>
|
||||
<li><code>A</code> 在 <code>B</code> 的左上角，并且</li>
|
||||
<li>它们形成的长方形中（或直线上）没有其它点（<strong>包括边界</strong>）。</li>
|
||||
</ul>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2024/01/04/example0alicebob-1.png" style="width: 750px; height: 308px;padding: 10px; background: #fff; border-radius: .5rem;" />
|
||||
|
||||
<p>返回数量。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/01/04/example1alicebob.png" style="width: 376px; height: 308px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem;" /></p>
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b>points = [[1,1],[2,2],[3,3]]</span></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>points = [[1,1],[2,2],[3,3]]
|
||||
<b>输出：</b>0
|
||||
<strong>解释：</strong>没有办法可以让 liupengsay 的围栏以 liupengsay 的位置为左上角且小羊肖恩的位置为右下角。所以我们返回 0 。
|
||||
</pre>
|
||||
<p><span class="example-io"><b>输出：</b>0</span></p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2024/01/04/example1alicebob.png" style="width: 427px; height: 350px;" /></p>
|
||||
|
||||
<p>没有办法选择 <code>A</code> 和 <code>B</code>，使得 <code>A</code> 在 <code>B</code> 的左上角。</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<p><strong class="example"><a href="https://pic.leetcode.cn/1706880313-YelabI-example2.jpeg"><img alt="" src="https://pic.leetcode.cn/1706880313-YelabI-example2.jpeg" style="width: 900px; height: 247px;" /></a></strong></p>
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b></span><span class="example-io">points = [[6,2],[4,4],[2,6]]</span></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>points = [[6,2],[4,4],[2,6]]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>总共有 2 种方案安排 liupengsay 和小羊肖恩的位置，使得 liupengsay 不会难过：
|
||||
- liupengsay 站在 (4, 4) ，小羊肖恩站在 (6, 2) 。
|
||||
- liupengsay 站在 (2, 6) ，小羊肖恩站在 (4, 4) 。
|
||||
不能安排 liupengsay 站在 (2, 6) 且小羊肖恩站在 (6, 2) ，因为站在 (4, 4) 的人处于围栏内。
|
||||
</pre>
|
||||
<p><span class="example-io"><b>输出：</b></span><span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<p><img height="365" src="https://assets.leetcode.com/uploads/2024/06/25/t2.jpg" width="1321" /></p>
|
||||
|
||||
<ul>
|
||||
<li>左边的是点对 <code>(points[1], points[0])</code>，其中 <code>points[1]</code> 在 <code>points[0]</code> 的左上角，并且形成的长方形内部是空的。</li>
|
||||
<li>中间的是点对 <code>(points[2], points[1])</code>，和左边的一样是合法的点对。</li>
|
||||
<li>右边的是点对 <code>(points[2], points[0])</code>，其中 <code>points[2]</code> 在 <code>points[0]</code> 的左上角，但 <code>points[1]</code> 在长方形内部，所以不是一个合法的点对。</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<p><strong class="example"><a href="https://pic.leetcode.cn/1706880311-mtPGYC-example3.jpeg"><img alt="" src="https://pic.leetcode.cn/1706880311-mtPGYC-example3.jpeg" style="width: 900px; height: 247px;" /></a></strong></p>
|
||||
<div class="example-block">
|
||||
<p><span class="example-io"><b>输入：</b></span><span class="example-io">points = [[3,1],[1,3],[1,1]]</span></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>points = [[3,1],[1,3],[1,1]]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>总共有 2 种方案安排 liupengsay 和小羊肖恩的位置，使得 liupengsay 不会难过：
|
||||
- liupengsay 站在 (1, 1) ，小羊肖恩站在 (3, 1) 。
|
||||
- liupengsay 站在 (1, 3) ，小羊肖恩站在 (1, 1) 。
|
||||
不能安排 liupengsay 站在 (1, 3) 且小羊肖恩站在 (3, 1) ，因为站在 (1, 1) 的人处于围栏内。
|
||||
注意围栏是可以不包含任何面积的，上图中第一和第二个围栏都是合法的。
|
||||
</pre>
|
||||
<p><span class="example-io"><b>输出：</b></span><span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>解释：</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2024/06/25/t3.jpg" style="width: 1269px; height: 350px;" /></p>
|
||||
|
||||
<ul>
|
||||
<li>左边的是点对 <code>(points[2], points[0])</code>，其中 <code>points[2]</code> 在 <code>points[0]</code> 的左上角并且在它们形成的直线上没有其它点。注意两个点形成一条线的情况是合法的。</li>
|
||||
<li>中间的是点对 <code>(points[1], points[2])</code>，和左边一样也是合法的点对。</li>
|
||||
<li>右边的是点对 <code>(points[1], points[0])</code>，它不是合法的点对，因为 <code>points[2]</code> 在长方形的边上。</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -2,15 +2,15 @@
|
||||
|
||||
<p>我们定义 x 轴的正方向为 <strong>右</strong> （<strong>x 轴递增的方向</strong>），x 轴的负方向为 <strong>左</strong> （<strong>x 轴递减的方向</strong>）。类似的，我们定义 y 轴的正方向为 <strong>上</strong> （<strong>y 轴递增的方向</strong>），y 轴的负方向为 <strong>下</strong> （<strong>y 轴递减的方向</strong>）。</p>
|
||||
|
||||
<p>你需要安排这 <code>n</code> 个人的站位，这 <code>n</code> 个人中包括 liupengsay 和小羊肖恩 。你需要确保每个点处 <strong>恰好</strong> 有 <strong>一个</strong> 人。同时，liupengsay 想跟小羊肖恩单独玩耍，所以 liupengsay 会以 liupengsay<b> </b>的坐标为 <strong>左上角</strong> ，小羊肖恩的坐标为 <strong>右下角</strong> 建立一个矩形的围栏（<strong>注意</strong>，围栏可能 <strong>不</strong> 包含任何区域，也就是说围栏可能是一条线段）。如果围栏的 <strong>内部</strong> 或者 <strong>边缘</strong> 上有任何其他人，liupengsay 都会难过。</p>
|
||||
<p>你需要安排这 <code>n</code> 个人的站位，这 <code>n</code> 个人中包括 Alice 和 Bob 。你需要确保每个点处 <strong>恰好</strong> 有 <strong>一个</strong> 人。同时，Alice 想跟 Bob 单独玩耍，所以 Alice 会以 Alice<b> </b>的坐标为 <strong>左上角</strong> ，Bob 的坐标为 <strong>右下角</strong> 建立一个矩形的围栏（<strong>注意</strong>，围栏可能 <strong>不</strong> 包含任何区域，也就是说围栏可能是一条线段）。如果围栏的 <strong>内部</strong> 或者 <strong>边缘</strong> 上有任何其他人，Alice 都会难过。</p>
|
||||
|
||||
<p>请你在确保 liupengsay <strong>不会</strong> 难过的前提下，返回 liupengsay 和小羊肖恩可以选择的 <strong>点对</strong> 数目。</p>
|
||||
<p>请你在确保 Alice <strong>不会</strong> 难过的前提下，返回 Alice 和 Bob 可以选择的 <strong>点对</strong> 数目。</p>
|
||||
|
||||
<p><b>注意</b>，liupengsay 建立的围栏必须确保 liupengsay 的位置是矩形的左上角，小羊肖恩的位置是矩形的右下角。比方说，以 <code>(1, 1)</code> ，<code>(1, 3)</code> ，<code>(3, 1)</code> 和 <code>(3, 3)</code> 为矩形的四个角，给定下图的两个输入，liupengsay 都不能建立围栏，原因如下：</p>
|
||||
<p><b>注意</b>，Alice 建立的围栏必须确保 Alice 的位置是矩形的左上角，Bob 的位置是矩形的右下角。比方说，以 <code>(1, 1)</code> ，<code>(1, 3)</code> ，<code>(3, 1)</code> 和 <code>(3, 3)</code> 为矩形的四个角，给定下图的两个输入，Alice 都不能建立围栏，原因如下：</p>
|
||||
|
||||
<ul>
|
||||
<li>图一中，liupengsay 在 <code>(3, 3)</code> 且小羊肖恩在 <code>(1, 1)</code> ，liupengsay 的位置不是左上角且小羊肖恩的位置不是右下角。</li>
|
||||
<li>图二中，liupengsay 在 <code>(1, 3)</code> 且小羊肖恩在 <code>(1, 1)</code> ，小羊肖恩的位置不是在围栏的右下角。</li>
|
||||
<li>图一中，Alice 在 <code>(3, 3)</code> 且 Bob 在 <code>(1, 1)</code> ，Alice 的位置不是左上角且 Bob 的位置不是右下角。</li>
|
||||
<li>图二中，Alice 在 <code>(1, 3)</code> 且 Bob 在 <code>(1, 1)</code> ，Bob 的位置不是在围栏的右下角。</li>
|
||||
</ul>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2024/01/04/example0alicebob-1.png" style="width: 750px; height: 308px;padding: 10px; background: #fff; border-radius: .5rem;" />
|
||||
<p> </p>
|
||||
@@ -22,33 +22,33 @@
|
||||
<pre>
|
||||
<b>输入：</b>points = [[1,1],[2,2],[3,3]]
|
||||
<b>输出：</b>0
|
||||
<strong>解释：</strong>没有办法可以让 liupengsay 的围栏以 liupengsay 的位置为左上角且小羊肖恩的位置为右下角。所以我们返回 0 。
|
||||
<strong>解释：</strong>没有办法可以让 Alice 的围栏以 Alice 的位置为左上角且 Bob 的位置为右下角。所以我们返回 0 。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<p><strong class="example"><a href="https://pic.leetcode.cn/1706880313-YelabI-example2.jpeg"><img alt="" src="https://pic.leetcode.cn/1706880313-YelabI-example2.jpeg" style="width: 900px; height: 250px;" /></a></strong></p>
|
||||
<p><strong class="example"><a href="https://pic.leetcode.cn/1706880313-YelabI-example2.jpeg"><img alt="" src="https://pic.leetcode.cn/1708226715-CxjXKb-20240218-112338.jpeg" style="width: 900px; height: 248px;" /></a></strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>points = [[6,2],[4,4],[2,6]]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>总共有 2 种方案安排 liupengsay 和小羊肖恩的位置，使得 liupengsay 不会难过：
|
||||
- liupengsay 站在 (4, 4) ，小羊肖恩站在 (6, 2) 。
|
||||
- liupengsay 站在 (2, 6) ，小羊肖恩站在 (4, 4) 。
|
||||
不能安排 liupengsay 站在 (2, 6) 且小羊肖恩站在 (6, 2) ，因为站在 (4, 4) 的人处于围栏内。
|
||||
<b>解释：</b>总共有 2 种方案安排 Alice 和 Bob 的位置，使得 Alice 不会难过：
|
||||
- Alice 站在 (4, 4) ，Bob 站在 (6, 2) 。
|
||||
- Alice 站在 (2, 6) ，Bob 站在 (4, 4) 。
|
||||
不能安排 Alice 站在 (2, 6) 且 Bob 站在 (6, 2) ，因为站在 (4, 4) 的人处于围栏内。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<p><strong class="example"><a href="https://pic.leetcode.cn/1706880311-mtPGYC-example3.jpeg"><img alt="" src="https://pic.leetcode.cn/1706880311-mtPGYC-example3.jpeg" style="width: 911px; height: 250px;" /></a></strong></p>
|
||||
<p><strong class="example"><a href="https://pic.leetcode.cn/1706880311-mtPGYC-example3.jpeg"><img alt="" src="https://pic.leetcode.cn/1708226721-wTbEuK-20240218-112351.jpeg" style="width: 911px; height: 250px;" /></a></strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>points = [[3,1],[1,3],[1,1]]
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>总共有 2 种方案安排 liupengsay 和小羊肖恩的位置，使得 liupengsay 不会难过：
|
||||
- liupengsay 站在 (1, 1) ，小羊肖恩站在 (3, 1) 。
|
||||
- liupengsay 站在 (1, 3) ，小羊肖恩站在 (1, 1) 。
|
||||
不能安排 liupengsay 站在 (1, 3) 且小羊肖恩站在 (3, 1) ，因为站在 (1, 1) 的人处于围栏内。
|
||||
<b>解释：</b>总共有 2 种方案安排 Alice 和 Bob 的位置，使得 Alice 不会难过：
|
||||
- Alice 站在 (1, 1) ，Bob 站在 (3, 1) 。
|
||||
- Alice 站在 (1, 3) ，Bob 站在 (1, 1) 。
|
||||
不能安排 Alice 站在 (1, 3) 且 Bob 站在 (3, 1) ，因为站在 (1, 1) 的人处于围栏内。
|
||||
注意围栏是可以不包含任何面积的，上图中第一和第二个围栏都是合法的。
|
||||
</pre>
|
||||
|
||||
|
||||
@@ -1,45 +1,45 @@
|
||||
<p>给你一个整数数组 <code>banned</code> 和两个整数 <code>n</code> 和 <code>maxSum</code> 。你需要按照以下规则选择一些整数：</p>
|
||||
|
||||
<ul>
|
||||
<li>被选择整数的范围是 <code>[1, n]</code> 。</li>
|
||||
<li>每个整数 <strong>至多</strong> 选择 <strong>一次</strong> 。</li>
|
||||
<li>被选择整数不能在数组 <code>banned</code> 中。</li>
|
||||
<li>被选择整数的和不超过 <code>maxSum</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回按照上述规则 <strong>最多</strong> 可以选择的整数数目。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>banned = [1,6,5], n = 5, maxSum = 6
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>你可以选择整数 2 和 4 。
|
||||
2 和 4 在范围 [1, 5] 内，且它们都不在 banned 中，它们的和是 6 ，没有超过 maxSum 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>banned = [1,2,3,4,5,6,7], n = 8, maxSum = 1
|
||||
<b>输出：</b>0
|
||||
<b>解释：</b>按照上述规则无法选择任何整数。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>banned = [11], n = 7, maxSum = 50
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>你可以选择整数 1, 2, 3, 4, 5, 6 和 7 。
|
||||
它们都在范围 [1, 7] 中，且都没出现在 banned 中，它们的和是 28 ，没有超过 maxSum 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= banned.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= banned[i], n <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= maxSum <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
<p>给你一个整数数组 <code>banned</code> 和两个整数 <code>n</code> 和 <code>maxSum</code> 。你需要按照以下规则选择一些整数：</p>
|
||||
|
||||
<ul>
|
||||
<li>被选择整数的范围是 <code>[1, n]</code> 。</li>
|
||||
<li>每个整数 <strong>至多</strong> 选择 <strong>一次</strong> 。</li>
|
||||
<li>被选择整数不能在数组 <code>banned</code> 中。</li>
|
||||
<li>被选择整数的和不超过 <code>maxSum</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回按照上述规则 <strong>最多</strong> 可以选择的整数数目。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>banned = [1,6,5], n = 5, maxSum = 6
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>你可以选择整数 2 和 4 。
|
||||
2 和 4 在范围 [1, 5] 内，且它们都不在 banned 中，它们的和是 6 ，没有超过 maxSum 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>banned = [1,2,3,4,5,6,7], n = 8, maxSum = 1
|
||||
<b>输出：</b>0
|
||||
<b>解释：</b>按照上述规则无法选择任何整数。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>banned = [11], n = 7, maxSum = 50
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>你可以选择整数 1, 2, 3, 4, 5, 6 和 7 。
|
||||
它们都在范围 [1, 7] 中，且都没出现在 banned 中，它们的和是 28 ，没有超过 maxSum 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= banned.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= banned[i], n <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= maxSum <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,26 +1,26 @@
|
||||
给你两个只包含 1 到 9 之间数字的数组 <code>nums1</code> 和 <code>nums2</code> ，每个数组中的元素 <strong>互不相同</strong> ，请你返回 <strong>最小</strong> 的数字，两个数组都 <strong>至少</strong> 包含这个数字的某个数位。
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums1 = [4,1,3], nums2 = [5,7]
|
||||
<b>输出：</b>15
|
||||
<b>解释：</b>数字 15 的数位 1 在 nums1 中出现，数位 5 在 nums2 中出现。15 是我们能得到的最小数字。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums1 = [3,5,2,6], nums2 = [3,1,7]
|
||||
<b>输出：</b>3
|
||||
<b>解释：</b>数字 3 的数位 3 在两个数组中都出现了。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 9</code></li>
|
||||
<li><code>1 <= nums1[i], nums2[i] <= 9</code></li>
|
||||
<li>每个数组中，元素 <strong>互不相同</strong> 。</li>
|
||||
</ul>
|
||||
给你两个只包含 1 到 9 之间数字的数组 <code>nums1</code> 和 <code>nums2</code> ，每个数组中的元素 <strong>互不相同</strong> ，请你返回 <strong>最小</strong> 的数字，两个数组都 <strong>至少</strong> 包含这个数字的某个数位。
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums1 = [4,1,3], nums2 = [5,7]
|
||||
<b>输出：</b>15
|
||||
<b>解释：</b>数字 15 的数位 1 在 nums1 中出现，数位 5 在 nums2 中出现。15 是我们能得到的最小数字。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums1 = [3,5,2,6], nums2 = [3,1,7]
|
||||
<b>输出：</b>3
|
||||
<b>解释：</b>数字 3 的数位 3 在两个数组中都出现了。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 9</code></li>
|
||||
<li><code>1 <= nums1[i], nums2[i] <= 9</code></li>
|
||||
<li>每个数组中，元素 <strong>互不相同</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,48 +1,48 @@
|
||||
<p>给你一个包含若干星号 <code>*</code> 的字符串 <code>s</code> 。</p>
|
||||
|
||||
<p>在一步操作中，你可以：</p>
|
||||
|
||||
<ul>
|
||||
<li>选中 <code>s</code> 中的一个星号。</li>
|
||||
<li>移除星号 <strong>左侧</strong> 最近的那个 <strong>非星号</strong> 字符，并移除该星号自身。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回移除 <strong>所有</strong> 星号之后的字符串<strong>。</strong></p>
|
||||
|
||||
<p><strong>注意：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>生成的输入保证总是可以执行题面中描述的操作。</li>
|
||||
<li>可以证明结果字符串是唯一的。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "leet**cod*e"
|
||||
<strong>输出：</strong>"lecoe"
|
||||
<strong>解释：</strong>从左到右执行移除操作：
|
||||
- 距离第 1 个星号最近的字符是 "lee<em><strong>t</strong></em>**cod*e" 中的 't' ，s 变为 "lee*cod*e" 。
|
||||
- 距离第 2 个星号最近的字符是 "le<em><strong>e</strong></em>*cod*e" 中的 'e' ，s 变为 "lecod*e" 。
|
||||
- 距离第 3 个星号最近的字符是 "leco<em><strong>d</strong></em>*e" 中的 'd' ，s 变为 "lecoe" 。
|
||||
不存在其他星号，返回 "lecoe" 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "erase*****"
|
||||
<strong>输出：</strong>""
|
||||
<strong>解释：</strong>整个字符串都会被移除，所以返回空字符串。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> 由小写英文字母和星号 <code>*</code> 组成</li>
|
||||
<li><code>s</code> 可以执行上述操作</li>
|
||||
</ul>
|
||||
<p>给你一个包含若干星号 <code>*</code> 的字符串 <code>s</code> 。</p>
|
||||
|
||||
<p>在一步操作中，你可以：</p>
|
||||
|
||||
<ul>
|
||||
<li>选中 <code>s</code> 中的一个星号。</li>
|
||||
<li>移除星号 <strong>左侧</strong> 最近的那个 <strong>非星号</strong> 字符，并移除该星号自身。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回移除 <strong>所有</strong> 星号之后的字符串<strong>。</strong></p>
|
||||
|
||||
<p><strong>注意：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>生成的输入保证总是可以执行题面中描述的操作。</li>
|
||||
<li>可以证明结果字符串是唯一的。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "leet**cod*e"
|
||||
<strong>输出：</strong>"lecoe"
|
||||
<strong>解释：</strong>从左到右执行移除操作：
|
||||
- 距离第 1 个星号最近的字符是 "lee<em><strong>t</strong></em>**cod*e" 中的 't' ，s 变为 "lee*cod*e" 。
|
||||
- 距离第 2 个星号最近的字符是 "le<em><strong>e</strong></em>*cod*e" 中的 'e' ，s 变为 "lecod*e" 。
|
||||
- 距离第 3 个星号最近的字符是 "leco<em><strong>d</strong></em>*e" 中的 'd' ，s 变为 "lecoe" 。
|
||||
不存在其他星号，返回 "lecoe" 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "erase*****"
|
||||
<strong>输出：</strong>""
|
||||
<strong>解释：</strong>整个字符串都会被移除，所以返回空字符串。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s</code> 由小写英文字母和星号 <code>*</code> 组成</li>
|
||||
<li><code>s</code> 可以执行上述操作</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,46 +1,46 @@
|
||||
<p>给你一个整数数组 <code>gifts</code> ，表示各堆礼物的数量。每一秒，你需要执行以下操作：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择礼物数量最多的那一堆。</li>
|
||||
<li>如果不止一堆都符合礼物数量最多，从中选择任一堆即可。</li>
|
||||
<li>选中的那一堆留下平方根数量的礼物（向下取整），取走其他的礼物。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回在 <code>k</code> 秒后剩下的礼物数量<em>。</em></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>gifts = [25,64,9,4,100], k = 4
|
||||
<strong>输出：</strong>29
|
||||
<strong>解释：</strong>
|
||||
按下述方式取走礼物：
|
||||
- 在第一秒，选中最后一堆，剩下 10 个礼物。
|
||||
- 接着第二秒选中第二堆礼物，剩下 8 个礼物。
|
||||
- 然后选中第一堆礼物，剩下 5 个礼物。
|
||||
- 最后，再次选中最后一堆礼物，剩下 3 个礼物。
|
||||
最后剩下的礼物数量分别是 [5,8,9,4,3] ，所以，剩下礼物的总数量是 29 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>gifts = [1,1,1,1], k = 4
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>
|
||||
在本例中，不管选中哪一堆礼物，都必须剩下 1 个礼物。
|
||||
也就是说，你无法获取任一堆中的礼物。
|
||||
所以，剩下礼物的总数量是 4 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= gifts.length <= 10<sup>3</sup></code></li>
|
||||
<li><code>1 <= gifts[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>3</sup></code></li>
|
||||
</ul>
|
||||
<p>给你一个整数数组 <code>gifts</code> ，表示各堆礼物的数量。每一秒，你需要执行以下操作：</p>
|
||||
|
||||
<ul>
|
||||
<li>选择礼物数量最多的那一堆。</li>
|
||||
<li>如果不止一堆都符合礼物数量最多，从中选择任一堆即可。</li>
|
||||
<li>将堆中的礼物数量减少到堆中原来礼物数量的平方根，向下取整。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回在 <code>k</code> 秒后剩下的礼物数量<em>。</em></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>gifts = [25,64,9,4,100], k = 4
|
||||
<strong>输出：</strong>29
|
||||
<strong>解释：</strong>
|
||||
按下述方式取走礼物：
|
||||
- 在第一秒，选中最后一堆，剩下 10 个礼物。
|
||||
- 接着第二秒选中第二堆礼物，剩下 8 个礼物。
|
||||
- 然后选中第一堆礼物，剩下 5 个礼物。
|
||||
- 最后，再次选中最后一堆礼物，剩下 3 个礼物。
|
||||
最后剩下的礼物数量分别是 [5,8,9,4,3] ，所以，剩下礼物的总数量是 29 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>gifts = [1,1,1,1], k = 4
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>
|
||||
在本例中，不管选中哪一堆礼物，都必须剩下 1 个礼物。
|
||||
也就是说，你无法获取任一堆中的礼物。
|
||||
所以，剩下礼物的总数量是 4 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= gifts.length <= 10<sup>3</sup></code></li>
|
||||
<li><code>1 <= gifts[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>3</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,37 +1,37 @@
|
||||
<p>给你一个链表的头节点 <code>head</code> 。</p>
|
||||
|
||||
<p>移除每个右侧有一个更大数值的节点。</p>
|
||||
|
||||
<p>返回修改后链表的头节点<em> </em><code>head</code><em> </em>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/10/02/drawio.png" style="width: 631px; height: 51px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [5,2,13,3,8]
|
||||
<strong>输出：</strong>[13,8]
|
||||
<strong>解释：</strong>需要移除的节点是 5 ，2 和 3 。
|
||||
- 节点 13 在节点 5 右侧。
|
||||
- 节点 13 在节点 2 右侧。
|
||||
- 节点 8 在节点 3 右侧。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,1,1,1]
|
||||
<strong>输出：</strong>[1,1,1,1]
|
||||
<strong>解释：</strong>每个节点的值都是 1 ，所以没有需要移除的节点。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>给定列表中的节点数目在范围 <code>[1, 10<sup>5</sup>]</code> 内</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
<p>给你一个链表的头节点 <code>head</code> 。</p>
|
||||
|
||||
<p>移除每个右侧有一个更大数值的节点。</p>
|
||||
|
||||
<p>返回修改后链表的头节点<em> </em><code>head</code><em> </em>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2022/10/02/drawio.png" style="width: 631px; height: 51px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [5,2,13,3,8]
|
||||
<strong>输出：</strong>[13,8]
|
||||
<strong>解释：</strong>需要移除的节点是 5 ，2 和 3 。
|
||||
- 节点 13 在节点 5 右侧。
|
||||
- 节点 13 在节点 2 右侧。
|
||||
- 节点 8 在节点 3 右侧。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,1,1,1]
|
||||
<strong>输出：</strong>[1,1,1,1]
|
||||
<strong>解释：</strong>每个节点的值都是 1 ，所以没有需要移除的节点。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>给定列表中的节点数目在范围 <code>[1, 10<sup>5</sup>]</code> 内</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,15 +1,13 @@
|
||||
<p>你的初始 <strong>能量</strong> 为 <code>power</code>，初始 <strong>分数</strong> 为 <code>0</code>，只有一包令牌 <code>tokens</code> 。其中 <code>tokens[i]</code> 是第 <code>i</code> 个令牌的值（下标从 0 开始）。</p>
|
||||
<p>你的初始 <strong>能量</strong> 为 <code>power</code>，初始 <strong>分数</strong> 为 <code>0</code>，只有一包令牌以整数数组 <code>tokens</code> 给出。其中 <code>tokens[i]</code> 是第 <code>i</code> 个令牌的值（下标从 0 开始）。</p>
|
||||
|
||||
<p>令牌可能的两种使用方法如下：</p>
|
||||
<p>你的目标是通过有策略地使用这些令牌以 <strong>最大化</strong> 总 <strong>分数</strong>。在一次行动中，你可以用两种方式中的一种来使用一个 <strong>未被使用的</strong> 令牌（但不是对同一个令牌使用两种方式）：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果你至少有 <code>token[i]</code> 点 <strong>能量</strong> ，可以将令牌 <code>i</code> 置为正面朝上，失去 <code>token[i]</code> 点 <strong>能量</strong> ，并得到 <code>1</code> <strong>分</strong> 。</li>
|
||||
<li>如果我们至少有 <code>1</code> <strong>分 </strong>，可以将令牌 <code>i</code> 置为反面朝上，获得 <code>token[i]</code> 点 <strong>能量</strong> ，并失去 <code>1</code> <strong>分</strong> 。</li>
|
||||
<li><strong>朝上</strong>：如果你当前 <strong>至少</strong> 有 <code>tokens[i]</code> 点 <strong>能量</strong> ，可以使用令牌 <code>i</code> ，失去 <code>tokens[i]</code> 点 <strong>能量</strong> ，并得到 <code>1</code> <strong>分</strong> 。</li>
|
||||
<li><strong>朝下</strong>：如果你当前至少有 <code>1</code> <strong>分 </strong>，可以使用令牌 <code>i</code> ，获得 <code>tokens[i]</code> 点 <strong>能量</strong> ，并失去 <code>1</code> <strong>分</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>每个令牌 <strong>最多</strong> 只能使用一次，使用 <strong>顺序不限</strong> ，<strong>不需</strong> 使用所有令牌。</p>
|
||||
|
||||
<p>在使用任意数量的令牌后，返回我们可以得到的最大 <strong>分数</strong> 。</p>
|
||||
<p>在使用 <strong>任意</strong> 数量的令牌后，返回我们可以得到的最大 <strong>分数</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -21,15 +19,15 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = [100], power = 50
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>无法使用唯一的令牌，因为能量和分数都太少了。</pre>
|
||||
<strong>解释：</strong>因为你的初始分数为 <code>0，</code>无法使令牌朝下。你也不能使令牌朝上因为你的能量（<code>50</code>）比 <code>tokens[0]</code> 少（<code>100</code>）。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = [100,200], power = 150
|
||||
<strong>输入：</strong>tokens = [200,100], power = 150
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>令牌 0 正面朝上，能量变为 50，分数变为 1 。
|
||||
不必使用令牌 1 ，因为你无法使用它来提高分数。</pre>
|
||||
<strong>解释：</strong>使令牌 1 正面朝上，能量变为 50，分数变为 1 。
|
||||
不必使用令牌 0，因为你无法使用它来提高分数。可得到的最大分数是 <code>1</code>。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
@@ -37,10 +35,13 @@
|
||||
<strong>输入：</strong>tokens = [100,200,300,400], power = 200
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>按下面顺序使用令牌可以得到 2 分：
|
||||
1. 令牌 0 正面朝上，能量变为 100 ，分数变为 1
|
||||
2. 令牌 3 正面朝下，能量变为 500 ，分数变为 0
|
||||
3. 令牌 1 正面朝上，能量变为 300 ，分数变为 1
|
||||
4. 令牌 2 正面朝上，能量变为 0 ，分数变为 2</pre>
|
||||
1. 令牌 0 (<code>100</code>)正面朝上，能量变为 <code>100</code> ，分数变为 <code>1</code>
|
||||
2. 令牌 3 (<code>400</code>)正面朝下，能量变为 <code>500</code> ，分数变为 <code>0</code>
|
||||
3. 令牌 1 (<code>200</code>)正面朝上，能量变为 <code>300</code> ，分数变为 <code>1</code>
|
||||
4. 令牌 2 (<code>300</code>)正面朝上，能量变为 <code>0</code> ，分数变为 <code>2</code>
|
||||
|
||||
可得的最大分数是 2。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -41,7 +41,7 @@ bms.gather(2, 0); // 返回 []
|
||||
bms.scatter(5, 1); // 返回 True
|
||||
// 这一组安排第 0 排第 4 个座位和第 1 排 [0, 3] 的座位。
|
||||
bms.scatter(5, 1); // 返回 False
|
||||
// 总共只剩下 2 个座位。
|
||||
// 总共只剩下 1 个座位。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -1,15 +1,51 @@
|
||||
<p>给你一个整数 <code>k</code> 和一个整数 <code>x</code> 。</p>
|
||||
<p>给你一个整数 <code>k</code> 和一个整数 <code>x</code> 。整数 <code>num</code> 的价值是它的二进制表示中在 <code>x</code>，<code>2x</code>，<code>3x</code> 等位置处 <strong><span data-keyword="set-bit">设置位</span></strong> 的数目（从最低有效位开始）。下面的表格包含了如何计算价值的例子。</p>
|
||||
|
||||
<p>令 <code>s</code> 为整数 <code>num</code> 的下标从 <strong>1</strong> 开始的二进制表示。我们说一个整数 <code>num</code> 的 <strong>价值</strong> 是满足 <code>i % x == 0</code> 且 <code><font face="monospace">s[i]</font></code> 是 <strong>设置位</strong> 的 <code>i</code> 的数目。</p>
|
||||
<table border="1">
|
||||
<tbody>
|
||||
<tr>
|
||||
<th>x</th>
|
||||
<th>num</th>
|
||||
<th>Binary Representation</th>
|
||||
<th>Price</th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>13</td>
|
||||
<td><u>0</u><u>0</u><u>0</u><u>0</u><u>0</u><strong><u>1</u></strong><strong><u>1</u></strong><u>0</u><strong><u>1</u></strong></td>
|
||||
<td>3</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>13</td>
|
||||
<td>0<u>0</u>0<u>0</u>0<strong><u>1</u></strong>1<u>0</u>1</td>
|
||||
<td>1</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>233</td>
|
||||
<td>0<strong><u>1</u></strong>1<strong><u>1</u></strong>0<strong><u>1</u></strong>0<u>0</u>1</td>
|
||||
<td>3</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>3</td>
|
||||
<td>13</td>
|
||||
<td><u>0</u>00<u>0</u>01<strong><u>1</u></strong>01</td>
|
||||
<td>1</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>3</td>
|
||||
<td>362</td>
|
||||
<td><strong><u>1</u></strong>01<strong><u>1</u></strong>01<u>0</u>10</td>
|
||||
<td>2</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p>请你返回<strong> 最大</strong> 整数<em> </em><code>num</code> ，满足从 <code>1</code> 到 <code>num</code> 的所有整数的 <strong>价值</strong> 和小于等于 <code>k</code> 。</p>
|
||||
<p> </p>
|
||||
|
||||
<p><b>注意：</b></p>
|
||||
<p><code>num</code> 的 <strong>累加价值</strong> 是从 <code>1</code> 到 <code>num</code> 的数字的 <strong>总</strong> 价值。如果 <code>num</code> 的累加价值小于或等于 <code>k</code> 则被认为是 <strong>廉价</strong> 的。</p>
|
||||
|
||||
<ul>
|
||||
<li>一个整数二进制表示下 <strong>设置位</strong> 是值为 <code>1</code> 的数位。</li>
|
||||
<li>一个整数的二进制表示下标从右到左编号，比方说如果 <code>s == 11100</code> ，那么 <code>s[4] == 1</code> 且 <code>s[2] == 0</code> 。</li>
|
||||
</ul>
|
||||
<p>请你返回<strong> 最大</strong> 的廉价数字。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -18,24 +54,159 @@
|
||||
<pre>
|
||||
<b>输入：</b>k = 9, x = 1
|
||||
<b>输出：</b>6
|
||||
<b>解释：</b>数字 1 ，2 ，3 ，4 ，5 和 6 二进制表示分别为 "1" ，"10" ，"11" ，"100" ，"101" 和 "110" 。
|
||||
由于 x 等于 1 ，每个数字的价值分别为所有设置位的数目。
|
||||
这些数字的所有设置位数目总数是 9 ，所以前 6 个数字的价值和为 9 。
|
||||
所以答案为 6 。</pre>
|
||||
<b>解释：</b>由下表所示，6 是最大的廉价数字。
|
||||
</pre>
|
||||
|
||||
<table border="1">
|
||||
<tbody>
|
||||
<tr>
|
||||
<th>x</th>
|
||||
<th>num</th>
|
||||
<th>Binary Representation</th>
|
||||
<th>Price</th>
|
||||
<th>Accumulated Price</th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>1</td>
|
||||
<td><u>0</u><u>0</u><strong><u>1</u></strong></td>
|
||||
<td>1</td>
|
||||
<td>1</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>2</td>
|
||||
<td><u>0</u><strong><u>1</u></strong><u>0</u></td>
|
||||
<td>1</td>
|
||||
<td>2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>3</td>
|
||||
<td><u>0</u><strong><u>1</u></strong><strong><u>1</u></strong></td>
|
||||
<td>2</td>
|
||||
<td>4</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>4</td>
|
||||
<td><strong><u>1</u></strong><u>0</u><u>0</u></td>
|
||||
<td>1</td>
|
||||
<td>5</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>5</td>
|
||||
<td><strong><u>1</u></strong><u>0</u><strong><u>1</u></strong></td>
|
||||
<td>2</td>
|
||||
<td>7</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>6</td>
|
||||
<td><strong><u>1</u></strong><strong><u>1</u></strong><u>0</u></td>
|
||||
<td>2</td>
|
||||
<td>9</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>1</td>
|
||||
<td>7</td>
|
||||
<td><strong><u>1</u></strong><strong><u>1</u></strong><strong><u>1</u></strong></td>
|
||||
<td>3</td>
|
||||
<td>12</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>k = 7, x = 2
|
||||
<b>输出：</b>9
|
||||
<b>解释：</b>由于 x 等于 2 ，我们检查每个数字的偶数位。
|
||||
2 和 3 在二进制表示下的第二个数位为设置位，所以它们的价值和为 2 。
|
||||
6 和 7 在二进制表示下的第二个数位为设置位，所以它们的价值和为 2 。
|
||||
8 和 9 在二进制表示下的第四个数位为设置位但第二个数位不是设置位，所以它们的价值和为 2 。
|
||||
数字 1 ，4 和 5 在二进制下偶数位都不是设置位，所以它们的价值和为 0 。
|
||||
10 在二进制表示下的第二个数位和第四个数位都是设置位，所以它的价值为 2 。
|
||||
前 9 个数字的价值和为 6 。
|
||||
前 10 个数字的价值和为 8，超过了 k = 7 ，所以答案为 9 。</pre>
|
||||
<b>解释：</b>由下表所示，9 是最大的廉价数字。
|
||||
</pre>
|
||||
|
||||
<table border="1">
|
||||
<tbody>
|
||||
<tr>
|
||||
<th>x</th>
|
||||
<th>num</th>
|
||||
<th>Binary Representation</th>
|
||||
<th>Price</th>
|
||||
<th>Accumulated Price</th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>1</td>
|
||||
<td><u>0</u>0<u>0</u>1</td>
|
||||
<td>0</td>
|
||||
<td>0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>2</td>
|
||||
<td><u>0</u>0<strong><u>1</u></strong>0</td>
|
||||
<td>1</td>
|
||||
<td>1</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>3</td>
|
||||
<td><u>0</u>0<strong><u>1</u></strong>1</td>
|
||||
<td>1</td>
|
||||
<td>2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>4</td>
|
||||
<td><u>0</u>1<u>0</u>0</td>
|
||||
<td>0</td>
|
||||
<td>2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>5</td>
|
||||
<td><u>0</u>1<u>0</u>1</td>
|
||||
<td>0</td>
|
||||
<td>2</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>6</td>
|
||||
<td><u>0</u>1<strong><u>1</u></strong>0</td>
|
||||
<td>1</td>
|
||||
<td>3</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>7</td>
|
||||
<td><u>0</u>1<strong><u>1</u></strong>1</td>
|
||||
<td>1</td>
|
||||
<td>4</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>8</td>
|
||||
<td><strong><u>1</u></strong>0<u>0</u>0</td>
|
||||
<td>1</td>
|
||||
<td>5</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>9</td>
|
||||
<td><strong><u>1</u></strong>0<u>0</u>1</td>
|
||||
<td>1</td>
|
||||
<td>6</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>2</td>
|
||||
<td>10</td>
|
||||
<td><strong><u>1</u></strong>0<strong><u>1</u></strong>0</td>
|
||||
<td>2</td>
|
||||
<td>8</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
|
||||
<p>返回表示修改后句子的字符串。</p>
|
||||
|
||||
<p>注意：所有价格 <strong>最多</strong> 为 <code>10</code> 位数字。</p>
|
||||
<p>注意：所有价格 <strong>最多</strong> 为 <code>10</code> 位数字。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -20,7 +20,7 @@
|
||||
<strong>解释：</strong>
|
||||
表示价格的单词是 "$1" 和 "$2" 。
|
||||
- "$1" 减免 50% 为 "$0.50" ，所以 "$1" 替换为 "$0.50" 。
|
||||
- "$2" 减免 50% 为 "$1" ，所以 "$1" 替换为 "$1.00" 。</pre>
|
||||
- "$2" 减免 50% 为 "$1" ，所以 "$2" 替换为 "$1.00" 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
|
||||
@@ -1,57 +1,57 @@
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的正整数数组 <code>tasks</code> ，表示需要 <strong>按顺序</strong> 完成的任务，其中 <code>tasks[i]</code> 表示第 <code>i</code> 件任务的 <strong>类型</strong> 。</p>
|
||||
|
||||
<p>同时给你一个正整数 <code>space</code> ，表示一个任务完成 <strong>后</strong> ，另一个 <strong>相同</strong> 类型任务完成前需要间隔的 <strong>最少</strong> 天数。</p>
|
||||
|
||||
<p>在所有任务完成前的每一天，你都必须进行以下两种操作中的一种：</p>
|
||||
|
||||
<ul>
|
||||
<li>完成 <code>tasks</code> 中的下一个任务</li>
|
||||
<li>休息一天</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回完成所有任务所需的 <strong>最少</strong> 天数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>tasks = [1,2,1,2,3,1], space = 3
|
||||
<b>输出：</b>9
|
||||
<strong>解释：</strong>
|
||||
9 天完成所有任务的一种方法是：
|
||||
第 1 天：完成任务 0 。
|
||||
第 2 天：完成任务 1 。
|
||||
第 3 天：休息。
|
||||
第 4 天：休息。
|
||||
第 5 天：完成任务 2 。
|
||||
第 6 天：完成任务 3 。
|
||||
第 7 天：休息。
|
||||
第 8 天：完成任务 4 。
|
||||
第 9 天：完成任务 5 。
|
||||
可以证明无法少于 9 天完成所有任务。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>tasks = [5,8,8,5], space = 2
|
||||
<b>输出：</b>6
|
||||
<strong>解释：</strong>
|
||||
6 天完成所有任务的一种方法是：
|
||||
第 1 天：完成任务 0 。
|
||||
第 2 天：完成任务 1 。
|
||||
第 3 天：休息。
|
||||
第 4 天：休息。
|
||||
第 5 天：完成任务 2 。
|
||||
第 6 天：完成任务 3 。
|
||||
可以证明无法少于 6 天完成所有任务。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= tasks.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= tasks[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= space <= tasks.length</code></li>
|
||||
</ul>
|
||||
<p>给你一个下标从 <strong>0</strong> 开始的正整数数组 <code>tasks</code> ，表示需要 <strong>按顺序</strong> 完成的任务，其中 <code>tasks[i]</code> 表示第 <code>i</code> 件任务的 <strong>类型</strong> 。</p>
|
||||
|
||||
<p>同时给你一个正整数 <code>space</code> ，表示一个任务完成 <strong>后</strong> ，另一个 <strong>相同</strong> 类型任务完成前需要间隔的 <strong>最少</strong> 天数。</p>
|
||||
|
||||
<p>在所有任务完成前的每一天，你都必须进行以下两种操作中的一种：</p>
|
||||
|
||||
<ul>
|
||||
<li>完成 <code>tasks</code> 中的下一个任务</li>
|
||||
<li>休息一天</li>
|
||||
</ul>
|
||||
|
||||
<p>请你返回完成所有任务所需的 <strong>最少</strong> 天数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>tasks = [1,2,1,2,3,1], space = 3
|
||||
<b>输出：</b>9
|
||||
<strong>解释：</strong>
|
||||
9 天完成所有任务的一种方法是：
|
||||
第 1 天：完成任务 0 。
|
||||
第 2 天：完成任务 1 。
|
||||
第 3 天：休息。
|
||||
第 4 天：休息。
|
||||
第 5 天：完成任务 2 。
|
||||
第 6 天：完成任务 3 。
|
||||
第 7 天：休息。
|
||||
第 8 天：完成任务 4 。
|
||||
第 9 天：完成任务 5 。
|
||||
可以证明无法少于 9 天完成所有任务。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>tasks = [5,8,8,5], space = 2
|
||||
<b>输出：</b>6
|
||||
<strong>解释：</strong>
|
||||
6 天完成所有任务的一种方法是：
|
||||
第 1 天：完成任务 0 。
|
||||
第 2 天：完成任务 1 。
|
||||
第 3 天：休息。
|
||||
第 4 天：休息。
|
||||
第 5 天：完成任务 2 。
|
||||
第 6 天：完成任务 3 。
|
||||
可以证明无法少于 6 天完成所有任务。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= tasks.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= tasks[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= space <= tasks.length</code></li>
|
||||
</ul>
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user