mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-06 07:51:41 +08:00
存量题库数据更新
This commit is contained in:
@@ -7,17 +7,17 @@
|
||||
| user_id | int |
|
||||
| time_stamp | datetime |
|
||||
+----------------+----------+
|
||||
(user_id, time_stamp) 是这个表的主键。
|
||||
(user_id, time_stamp) 是这个表的主键(具有唯一值的列的组合)。
|
||||
每一行包含的信息是user_id 这个用户的登录时间。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>编写一个 SQL 查询，该查询可以获取在 <code>2020</code> 年登录过的所有用户的本年度 <strong>最后一次 </strong>登录时间。结果集 <strong>不</strong> 包含 <code>2020</code> 年没有登录过的用户。</p>
|
||||
<p>编写解决方案以获取在 <code>2020</code> 年登录过的所有用户的本年度 <strong>最后一次 </strong>登录时间。结果集 <strong>不</strong> 包含 <code>2020</code> 年没有登录过的用户。</p>
|
||||
|
||||
<p>返回的结果集可以按 <strong>任意顺序 </strong>排列。</p>
|
||||
|
||||
<p>查询结果格式如下例。</p>
|
||||
<p>返回结果格式如下例。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,56 +1,49 @@
|
||||
<p>Dota2 的世界里有两个阵营：<code>Radiant</code>(天辉)和 <code>Dire</code>(夜魇)</p>
|
||||
<p>Dota2 的世界里有两个阵营：<code>Radiant</code>（天辉）和 <code>Dire</code>（夜魇）</p>
|
||||
|
||||
<p>Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的<code><strong>一</strong></code>项：</p>
|
||||
<p>Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的 <strong>一 </strong>项：</p>
|
||||
|
||||
<ol>
|
||||
<li>
|
||||
<p><code>禁止一名参议员的权利</code>：</p>
|
||||
<ul>
|
||||
<li><strong>禁止一名参议员的权利</strong>：参议员可以让另一位参议员在这一轮和随后的几轮中丧失<strong> 所有的权利 </strong>。</li>
|
||||
<li><strong>宣布胜利</strong>：如果参议员发现有权利投票的参议员都是 <strong>同一个阵营的</strong> ，他可以宣布胜利并决定在游戏中的有关变化。</li>
|
||||
</ul>
|
||||
|
||||
<p>参议员可以让另一位参议员在这一轮和随后的几轮中丧失<strong>所有的权利</strong>。</p>
|
||||
</li>
|
||||
<li>
|
||||
<p><code>宣布胜利</code>：</p>
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
<p> 如果参议员发现有权利投票的参议员都是<strong>同一个阵营的</strong>，他可以宣布胜利并决定在游戏中的有关变化。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>给定一个字符串代表每个参议员的阵营。字母 “R” 和 “D” 分别代表了 <code>Radiant</code>（天辉）和 <code>Dire</code>（夜魇）。然后，如果有 <code>n</code> 个参议员，给定字符串的大小将是 <code>n</code>。</p>
|
||||
<p>给你一个字符串 <code>senate</code> 代表每个参议员的阵营。字母 <code>'R'</code> 和 <code>'D'</code>分别代表了 <code>Radiant</code>（天辉）和 <code>Dire</code>（夜魇）。然后，如果有 <code>n</code> 个参议员，给定字符串的大小将是 <code>n</code>。</p>
|
||||
|
||||
<p>以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束。这一过程将持续到投票结束。所有失去权利的参议员将在过程中被跳过。</p>
|
||||
|
||||
<p>假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是 <code>Radiant</code> 或 <code>Dire</code>。</p>
|
||||
<p>假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是 <code>"Radiant"</code> 或 <code>"Dire"</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>"RD"
|
||||
<strong>输入：</strong>senate = "RD"
|
||||
<strong>输出：</strong>"Radiant"
|
||||
<strong>解释：</strong><code>第一个参议员来自 Radiant 阵营并且他可以使用第一项权利让第二个参议员失去权力，因此第二个参议员将被跳过因为他没有任何权利。然后在第二轮的时候，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人</code>
|
||||
<strong>解释：
|
||||
</strong><code>第 1 轮时，第一个参议员来自 Radiant 阵营，他可以使用第一项权利让第二个参议员失去所有权利。
|
||||
这一轮中，第二个参议员将会被跳过，因为他的权利被禁止了。
|
||||
第 2 轮时，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人</code>。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>"RDD"
|
||||
<strong>输入：</strong>senate = "RDD"
|
||||
<strong>输出：</strong>"Dire"
|
||||
<strong>解释：</strong>
|
||||
第一轮中,第一个<code>来自 Radiant 阵营的</code>参议员可以使用第一项权利禁止第二个参议员的权利
|
||||
第二个<code>来自 Dire 阵营的</code>参议员会被跳过因为他的权利被禁止
|
||||
第三个<code>来自 Dire 阵营的</code>参议员可以使用他的第一项权利禁止第一个参议员的权利
|
||||
第 1 轮时，第一个<code>来自 Radiant 阵营的</code>参议员可以使用第一项权利禁止第二个参议员的权利。
|
||||
<code>这一轮中，</code>第二个<code>来自 Dire 阵营的</code>参议员会将被跳过，因为他的权利被禁止了。
|
||||
<code>这一轮中，</code>第三个<code>来自 Dire 阵营的</code>参议员可以使用他的第一项权利禁止第一个参议员的权利。
|
||||
因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>给定字符串的长度在 <code>[1, 10,000]</code> 之间.</li>
|
||||
<li><code>n == senate.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>senate[i]</code> 为 <code>'R'</code> 或 <code>'D'</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -1,35 +1,33 @@
|
||||
<p>给你一个整数数组 <code>citations</code> ，其中 <code>citations[i]</code> 表示研究者的第 <code>i</code> 篇论文被引用的次数，<code>citations</code> 已经按照 <strong>升序排列 </strong>。计算并返回该研究者的 <strong><code>h</code><em> </em>指数</strong>。</p>
|
||||
<p>给你一个整数数组 <code>citations</code> ，其中 <code>citations[i]</code> 表示研究者的第 <code>i</code> 篇论文被引用的次数，<code>citations</code> 已经按照 <strong>升序排列 </strong>。计算并返回该研究者的 h<strong><em> </em></strong>指数。</p>
|
||||
|
||||
<p><a href="https://baike.baidu.com/item/h-index/3991452?fr=aladdin" target="_blank">h 指数的定义</a>：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （<code>n</code> 篇论文中）<strong>总共</strong>有 <code>h</code> 篇论文分别被引用了<strong>至少</strong> <code>h</code> 次。且其余的 <em><code>n - h</code> </em>篇论文每篇被引用次数 <strong>不超过 </strong><em><code>h</code> </em>次。</p>
|
||||
|
||||
<p><strong>提示：</strong>如果 <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>：h 代表“高引用次数”（high citations），一名科研人员的 <code>h</code> 指数是指他（她）的 （<code>n</code> 篇论文中）<strong>至少 </strong>有 <code>h</code> 篇论文分别被引用了<strong>至少</strong> <code>h</code> 次。</p>
|
||||
|
||||
<p>请你设计并实现对数时间复杂度的算法解决此问题。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入<code>：</code></strong><code>citations = [0,1,3,5,6]</code>
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>给定数组表示研究者总共有 <code>5</code> 篇论文，每篇论文相应的被引用了 0<code>, 1, 3, 5, 6</code> 次。
|
||||
由于研究者有 <code>3 </code>篇论文每篇<strong> 至少 </strong>被引用了 <code>3</code> 次，其余两篇论文每篇被引用<strong> 不多于</strong> <code>3</code> 次，所以她的<em> h </em>指数是 <code>3</code> 。</pre>
|
||||
<strong>输入：</strong><code>citations = [0,1,3,5,6]</code>
|
||||
<strong>输出：</strong><code>3</code>
|
||||
<strong>解释：</strong>给定数组表示研究者总共有 <code>5</code> 篇论文，每篇论文相应的被引用了 <code>0, 1, 3, 5, 6</code> 次。
|
||||
由于研究者有<code>3</code>篇论文每篇<strong> 至少 </strong>被引用了 <code>3</code> 次，其余两篇论文每篇被引用<strong> 不多于</strong> <code>3</code> 次，所以她的<em> h </em>指数是 <code>3</code> 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>citations = [1,2,100]
|
||||
<strong>输出：</strong>2
|
||||
<strong>输入：</strong><code>citations = [1,2,100]</code>
|
||||
<strong>输出：</strong><code>2</code>
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == citations.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= citations[i] <= 1000</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= citations[i] <= 1000</code></li>
|
||||
<li><code>citations</code> 按 <strong>升序排列</strong></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,8 +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>：h 代表“高引用次数”，一名科研人员的 <code>h</code><strong>指数</strong>是指他（她）的 （<code>n</code> 篇论文中）<strong>总共</strong>有 <code>h</code> 篇论文分别被引用了<strong>至少</strong> <code>h</code> 次。且其余的 <em><code>n - h</code> </em>篇论文每篇被引用次数 <strong>不超过 </strong><em><code>h</code> </em>次。</p>
|
||||
|
||||
<p>如果 <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><em> </em>有多种可能的值，<strong><code>h</code> 指数 </strong>是其中最大的那个。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,42 +1,42 @@
|
||||
力扣嘉年华同样准备了纪念品展位，参观者只需要集齐 `helloleetcode` 的 `13` 张字母卡片即可获得力扣纪念章。
|
||||
|
||||
|
||||
|
||||
在展位上有一些由字母卡片拼成的单词，`words[i][j]` 表示第 `i` 个单词的第 `j` 个字母。
|
||||
|
||||
|
||||
|
||||
你可以从这些单词中取出一些卡片，但每次拿取卡片都需要消耗游戏代币，规则如下：
|
||||
|
||||
|
||||
|
||||
- 从一个单词中取一个字母所需要的代币数量，为该字母左边和右边字母数量之积
|
||||
|
||||
|
||||
|
||||
- 可以从一个单词中多次取字母，每个字母仅可被取一次
|
||||
|
||||
|
||||
|
||||
> 例如：从 `example` 中取出字母 `a`，需要消耗代币 `2*4=8`，字母取出后单词变为 `exmple`；
|
||||
|
||||
再从中取出字母 `m`，需要消耗代币 `2*3=6`，字母取出后单词变为 `exple`；
|
||||
|
||||
|
||||
|
||||
请返回取得 `helloleetcode` 这些字母需要消耗代币的 **最少** 数量。如果无法取得，返回 `-1`。
|
||||
|
||||
|
||||
|
||||
**注意：**
|
||||
|
||||
- 取出字母的顺序没有要求
|
||||
|
||||
- 取出的所有字母恰好可以拼成 `helloleetcode`
|
||||
|
||||
|
||||
|
||||
**示例 1：**
|
||||
|
||||
>输入：`words = ["hold","engineer","cost","level"]`
|
||||
力扣嘉年华同样准备了纪念品展位，参观者只需要集齐 `helloleetcode` 的 `13` 张字母卡片即可获得力扣纪念章。
|
||||
|
||||
在展位上有一些由字母卡片拼成的单词，`words[i][j]` 表示第 `i` 个单词的第 `j` 个字母。
|
||||
|
||||
你可以从这些单词中取出一些卡片，但每次拿取卡片都需要消耗游戏代币，规则如下：
|
||||
|
||||
- 从一个单词中取一个字母所需要的代币数量，为该字母左边和右边字母数量之积
|
||||
|
||||
- 可以从一个单词中多次取字母，每个字母仅可被取一次
|
||||
|
||||
> 例如：从 `example` 中取出字母 `a`，需要消耗代币 `2*4=8`，字母取出后单词变为 `exmple`；
|
||||
再从中取出字母 `m`，需要消耗代币 `2*3=6`，字母取出后单词变为 `exple`；
|
||||
|
||||
请返回取得 `helloleetcode` 这些字母需要消耗代币的 **最少** 数量。如果无法取得，返回 `-1`。
|
||||
|
||||
**注意：**
|
||||
- 取出字母的顺序没有要求
|
||||
- 取出的所有字母恰好可以拼成 `helloleetcode`
|
||||
|
||||
**示例 1：**
|
||||
>输入：`words = ["hold","engineer","cost","level"]`
|
||||
>
|
||||
>输出：`5`
|
||||
>
|
||||
>解释：最优方法为：
|
||||
>从 `hold` 依次取出 `h`、`o`、`l`、`d`， 代价均为 `0`
|
||||
>从 `engineer` 依次取出第 `1` 个 `e` 与最后一个 `e`， 代价为 `0` 和 `5*1=5`
|
||||
>从 `cost` 取出 `c`、`o`、`t`， 代价均为 `0`
|
||||
>从 `level` 依次取出 `l`、`l`、`e`、`e`， 代价均为 `0`
|
||||
>所有字母恰好可以拼成 `helloleetcode`，因此最小的代价为 `5`
|
||||
|
||||
**示例 2：**
|
||||
>输入：`words = ["hello","leetcode"]`
|
||||
>
|
||||
>输出：`0`
|
||||
|
||||
**提示：**
|
||||
+ `n == words.length`
|
||||
+ `m == words[i].length`
|
||||
+ `1 <= n <= 24`
|
||||
+ `1 <= m <= 8`
|
||||
+ `words[i][j]` 仅为小写字母
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>给定一个正整数数组 <code>nums</code>和一个整数 <font color="#c7254e"><font face="Menlo, Monaco, Consolas, Courier New, monospace"><span style="font-size:12.6px"><span style="background-color:#f9f2f4">k</span></span></font></font> ，返回 <font color="#c7254e"><font face="Menlo, Monaco, Consolas, Courier New, monospace"><span style="font-size:12.6px"><span style="background-color:#f9f2f4">num</span></span></font></font> 中 「<strong>好子数组」</strong><em> </em>的数目。</p>
|
||||
<p>给定一个正整数数组 <code>nums</code>和一个整数 <code>k</code>，返回 <code>nums</code> 中 「<strong>好子数组」</strong><em> </em>的数目。</p>
|
||||
|
||||
<p>如果 <code>nums</code> 的某个子数组中不同整数的个数恰好为 <code>k</code>，则称 <code>nums</code> 的这个连续、不一定不同的子数组为 <strong>「</strong><strong>好子数组 」</strong>。</p>
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
<ul>
|
||||
<li><code>numOnes</code> 件标记为 <code>1</code> 的物品。</li>
|
||||
<li><code>numZeroes</code> 件标记为 <code>0</code> 的物品。</li>
|
||||
<li><code>numZeros</code> 件标记为 <code>0</code> 的物品。</li>
|
||||
<li><code>numNegOnes</code> 件标记为 <code>-1</code> 的物品。</li>
|
||||
</ul>
|
||||
|
||||
@@ -16,14 +16,16 @@
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2
|
||||
<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
|
||||
<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 是所有可行方案中的最大值。
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
<ul>
|
||||
<li><code>LFUCache(int capacity)</code> - 用数据结构的容量 <code>capacity</code> 初始化对象</li>
|
||||
<li><code>int get(int key)</code> - 如果键 <code>key</code> 存在于缓存中，则获取键的值，否则返回 <code>-1</code> 。</li>
|
||||
<li><code>void put(int key, int value)</code> - 如果键 <code>key</code> 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量 <code>capacity</code> 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 <strong>最近最久未使用</strong> 的键。</li>
|
||||
<li><code>void put(int key, int value)</code> - 如果键 <code>key</code> 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量 <code>capacity</code> 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 <strong>最久未使用</strong> 的键。</li>
|
||||
</ul>
|
||||
|
||||
<p>为了确定最不常使用的键，可以为缓存中的每个键维护一个 <strong>使用计数器</strong> 。使用计数最小的键是最久未使用的键。</p>
|
||||
@@ -51,7 +51,7 @@ lfu.get(4); // 返回 4
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= capacity <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= capacity <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= key <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= value <= 10<sup>9</sup></code></li>
|
||||
<li>最多调用 <code>2 * 10<sup>5</sup></code> 次 <code>get</code> 和 <code>put</code> 方法</li>
|
||||
|
||||
@@ -1,29 +1,26 @@
|
||||
<p>8 间牢房排成一排，每间牢房不是有人住就是空着。</p>
|
||||
<p>监狱中 <code>8</code> 间牢房排成一排，每间牢房可能被占用或空置。</p>
|
||||
|
||||
<p>每天，无论牢房是被占用或空置，都会根据以下规则进行更改：</p>
|
||||
<p>每天，无论牢房是被占用或空置，都会根据以下规则进行变更：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果一间牢房的两个相邻的房间都被占用或都是空的，那么该牢房就会被占用。</li>
|
||||
<li>否则，它就会被空置。</li>
|
||||
</ul>
|
||||
|
||||
<p>（请注意，由于监狱中的牢房排成一行，所以行中的第一个和最后一个房间无法有两个相邻的房间。）</p>
|
||||
<p><strong>注意</strong>：由于监狱中的牢房排成一行，所以行中的第一个和最后一个牢房不存在两个相邻的房间。</p>
|
||||
|
||||
<p>我们用以下方式描述监狱的当前状态：如果第 <code>i</code> 间牢房被占用，则 <code>cell[i]==1</code>，否则 <code>cell[i]==0</code>。</p>
|
||||
<p>给你一个整数数组 <code>cells</code> ，用于表示牢房的初始状态：如果第 <code>i</code> 间牢房被占用，则 <code>cell[i]==1</code>，否则 <code>cell[i]==0</code> 。另给你一个整数 <code>n</code> 。</p>
|
||||
|
||||
<p>根据监狱的初始状态，在 <code>N</code> 天后返回监狱的状况（和上述 N 种变化）。</p>
|
||||
<p>请你返回 <code>n</code> 天后监狱的状况（即，按上文描述进行 <code>n</code> 次变更）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<ol>
|
||||
</ol>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>cells = [0,1,0,1,1,0,0,1], N = 7
|
||||
<pre>
|
||||
<strong>输入：</strong>cells = [0,1,0,1,1,0,0,1], n = 7
|
||||
<strong>输出：</strong>[0,0,1,1,0,0,0,0]
|
||||
<strong>解释：
|
||||
</strong>下表概述了监狱每天的状况：
|
||||
<strong>解释：</strong>下表总结了监狱每天的状况：
|
||||
Day 0: [0, 1, 0, 1, 1, 0, 0, 1]
|
||||
Day 1: [0, 1, 1, 0, 0, 0, 0, 0]
|
||||
Day 2: [0, 0, 0, 0, 1, 1, 1, 0]
|
||||
@@ -32,12 +29,12 @@ Day 4: [0, 0, 0, 0, 0, 1, 0, 0]
|
||||
Day 5: [0, 1, 1, 1, 0, 1, 0, 0]
|
||||
Day 6: [0, 0, 1, 0, 1, 1, 0, 0]
|
||||
Day 7: [0, 0, 1, 1, 0, 0, 0, 0]
|
||||
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>cells = [1,0,0,1,0,0,1,0], N = 1000000000
|
||||
<pre>
|
||||
<strong>输入：</strong>cells = [1,0,0,1,0,0,1,0], n = 1000000000
|
||||
<strong>输出：</strong>[0,0,1,1,1,1,1,0]
|
||||
</pre>
|
||||
|
||||
@@ -45,8 +42,8 @@ Day 7: [0, 0, 1, 1, 0, 0, 0, 0]
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ol>
|
||||
<ul>
|
||||
<li><code>cells.length == 8</code></li>
|
||||
<li><code>cells[i]</code> 的值为 <code>0</code> 或 <code>1</code> </li>
|
||||
<li><code>1 <= N <= 10^9</code></li>
|
||||
</ol>
|
||||
<li><code>cells[i]</code> 为 <code>0</code> 或 <code>1</code></li>
|
||||
<li><code>1 <= n <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
<p>按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。</p>
|
||||
|
||||
<p><strong>n 皇后问题</strong> 研究的是如何将 <code>n</code> 个皇后放置在 <code>n×n</code> 的棋盘上，并且使皇后彼此之间不能相互攻击。</p>
|
||||
|
||||
<p>给你一个整数 <code>n</code> ，返回所有不同的 <strong>n<em> </em>皇后问题</strong> 的解决方案。</p>
|
||||
|
||||
@@ -26,13 +26,18 @@
|
||||
|
||||
<strong>解释</strong>
|
||||
RandomizedCollection collection = new RandomizedCollection();// 初始化一个空的集合。
|
||||
collection.insert(1);// 向集合中插入 1 。返回 true 表示集合不包含 1 。
|
||||
collection.insert(1);// 向集合中插入另一个 1 。返回 false 表示集合包含 1 。集合现在包含 [1,1] 。
|
||||
collection.insert(2);// 向集合中插入 2 ，返回 true 。集合现在包含 [1,1,2] 。
|
||||
collection.getRandom();// getRandom 应当有 2/3 的概率返回 1 ，1/3 的概率返回 2 。
|
||||
collection.remove(1);// 从集合中删除 1 ，返回 true 。集合现在包含 [1,2] 。
|
||||
collection.getRandom();// getRandom 应有相同概率返回 1 和 2 。
|
||||
</pre>
|
||||
collection.insert(1); // 返回 true，因为集合不包含 1。
|
||||
// 将 1 插入到集合中。
|
||||
collection.insert(1); // 返回 false，因为集合包含 1。
|
||||
// 将另一个 1 插入到集合中。集合现在包含 [1,1]。
|
||||
collection.insert(2); // 返回 true，因为集合不包含 2。
|
||||
// 将 2 插入到集合中。集合现在包含 [1,1,2]。
|
||||
collection.getRandom(); // getRandom 应当:
|
||||
// 有 2/3 的概率返回 1,
|
||||
// 1/3 的概率返回 2。
|
||||
collection.remove(1); // 返回 true，因为集合包含 1。
|
||||
// 从集合中移除 1。集合现在包含 [1,2]。
|
||||
collection.getRandom(); // getRandom 应该返回 1 或 2，两者的可能性相同。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,22 +1,22 @@
|
||||
<p>实现 <a href="https://www.cplusplus.com/reference/valarray/pow/" target="_blank">pow(<em>x</em>, <em>n</em>)</a> ，即计算 <code>x</code> 的 <code>n</code> 次幂函数（即，<code>x<sup>n</sup></code><sup><span style="font-size:10.8333px"> </span></sup>）。</p>
|
||||
<p>实现 <a href="https://www.cplusplus.com/reference/valarray/pow/" target="_blank">pow(<em>x</em>, <em>n</em>)</a> ，即计算 <code>x</code> 的整数 <code>n</code> 次幂函数（即，<code>x<sup>n</sup></code><sup><span style="font-size:10.8333px"> </span></sup>）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 2.00000, n = 10
|
||||
<strong>输出：</strong>1024.00000
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 2.10000, n = 3
|
||||
<strong>输出：</strong>9.26100
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 2.00000, n = -2
|
||||
@@ -31,5 +31,7 @@
|
||||
<ul>
|
||||
<li><code>-100.0 < x < 100.0</code></li>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code></li>
|
||||
<li><code>n</code> 是一个整数</li>
|
||||
<li>要么 <code>x</code> 不为零，要么 <code>n > 0</code> 。</li>
|
||||
<li><code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>实现 <a href="https://www.cplusplus.com/reference/valarray/pow/">pow(<em>x</em>, <em>n</em>)</a> ，即计算 x 的 n 次幂函数（即，x<sup>n</sup>）。不得使用库函数，同时不需要考虑大数问题。</p>
|
||||
<p>实现 <a href="https://www.cplusplus.com/reference/valarray/pow/">pow(<em>x</em>, <em>n</em>)</a> ，即计算 x 的 n 次幂函数（即，x<sup>n</sup>）。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -22,16 +22,18 @@
|
||||
<strong>输出：</strong>0.25000
|
||||
<strong>解释：</strong>2<sup>-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-100.0 < x < 100.0</code></li>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code></li>
|
||||
<li><code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code></li>
|
||||
<li><code>-100.0 < x < 100.0</code></li>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code></li>
|
||||
<li><code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p>注意：本题与主站 50 题相同：<a href="https://leetcode-cn.com/problems/powx-n/">https://leetcode-cn.com/problems/powx-n/</a></p>
|
||||
|
||||
<p> </p>
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>给你一棵由 n 个顶点组成的无向树，顶点编号从 1 到 <code>n</code>。青蛙从 <strong>顶点 1</strong> 开始起跳。规则如下：</p>
|
||||
<p>给你一棵由 <code>n</code> 个顶点组成的无向树，顶点编号从 <code>1</code> 到 <code>n</code>。青蛙从 <strong>顶点 1</strong> 开始起跳。规则如下：</p>
|
||||
|
||||
<ul>
|
||||
<li>在一秒内，青蛙从它所在的当前顶点跳到另一个 <strong>未访问</strong> 过的顶点（如果它们直接相连）。</li>
|
||||
@@ -7,9 +7,9 @@
|
||||
<li>如果青蛙不能跳到任何未访问过的顶点上，那么它每次跳跃都会停留在原地。</li>
|
||||
</ul>
|
||||
|
||||
<p>无向树的边用数组 <code>edges</code> 描述，其中 <code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>]</code> 意味着存在一条直接连通 <code>from<sub>i</sub></code> 和 <code>to<sub>i</sub></code> 两个顶点的边。</p>
|
||||
<p>无向树的边用数组 <code>edges</code> 描述，其中 <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> 意味着存在一条直接连通 <code>a<sub>i</sub></code> 和 <code>b<sub>i</sub></code> 两个顶点的边。</p>
|
||||
|
||||
<p>返回青蛙在 <em><code>t</code></em> 秒后位于目标顶点 <em><code>target</code> </em>上的概率。</p>
|
||||
<p>返回青蛙在 <em><code>t</code></em> 秒后位于目标顶点 <em><code>target</code> </em>上的概率。与实际答案相差不超过 <code>10<sup>-5</sup></code> 的结果将被视为正确答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,3 +1,38 @@
|
||||
<p>TinyURL是一种URL简化服务， 比如：当你输入一个URL <code>https://leetcode.com/problems/design-tinyurl</code> 时，它将返回一个简化的URL <code>http://tinyurl.com/4e9iAk</code>.</p>
|
||||
<p>TinyURL 是一种 URL 简化服务， 比如：当你输入一个 URL <code>https://leetcode.com/problems/design-tinyurl</code> 时，它将返回一个简化的URL <code>http://tinyurl.com/4e9iAk</code> 。请你设计一个类来加密与解密 TinyURL 。</p>
|
||||
|
||||
<p>要求：设计一个 TinyURL 的加密 <code>encode</code> 和解密 <code>decode</code> 的方法。你的加密和解密算法如何设计和运作是没有限制的，你只需要保证一个URL可以被加密成一个TinyURL，并且这个TinyURL可以用解密方法恢复成原本的URL。</p>
|
||||
<p>加密和解密算法如何设计和运作是没有限制的，你只需要保证一个 URL 可以被加密成一个 TinyURL ，并且这个 TinyURL 可以用解密方法恢复成原本的 URL 。</p>
|
||||
|
||||
<p>实现 <code>Solution</code> 类：</p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<ul>
|
||||
<li><code>Solution()</code> 初始化 TinyURL 系统对象。</li>
|
||||
<li><code>String encode(String longUrl)</code> 返回 <code>longUrl</code> 对应的 TinyURL 。</li>
|
||||
<li><code>String decode(String shortUrl)</code> 返回 <code>shortUrl</code> 原本的 URL 。题目数据保证给定的 <code>shortUrl</code> 是由同一个系统对象加密的。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>url = "https://leetcode.com/problems/design-tinyurl"
|
||||
<strong>输出：</strong>"https://leetcode.com/problems/design-tinyurl"
|
||||
|
||||
<strong>解释：</strong>
|
||||
Solution obj = new Solution();
|
||||
string tiny = obj.encode(url); // 返回加密后得到的 TinyURL 。
|
||||
string ans = obj.decode(tiny); // 返回解密后得到的原本的 URL 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= url.length <= 10<sup>4</sup></code></li>
|
||||
<li>题目数据保证 <code>url</code> 是一个有效的 URL</li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -10,15 +10,17 @@
|
||||
<p>这是 UTF-8 编码的工作方式：</p>
|
||||
|
||||
<pre>
|
||||
<code> Char. number range | UTF-8 octet sequence
|
||||
(hexadecimal) | (binary)
|
||||
<code> </code>Number of Bytes<code> | UTF-8 octet sequence
|
||||
| (binary)
|
||||
--------------------+---------------------------------------------
|
||||
0000 0000-0000 007F | 0xxxxxxx
|
||||
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
|
||||
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
|
||||
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
||||
1 | 0xxxxxxx
|
||||
2 | 110xxxxx 10xxxxxx
|
||||
3 | 1110xxxx 10xxxxxx 10xxxxxx
|
||||
4 | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
||||
</code></pre>
|
||||
|
||||
<p><code>x</code> 表示二进制形式的一位，可以是 <code>0</code> 或 <code>1</code>。</p>
|
||||
|
||||
<p><strong>注意：</strong>输入是整数数组。只有每个整数的 <strong>最低 8 个有效位</strong> 用来存储数据。这意味着每个整数只表示 1 字节的数据。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
<p>如果正整数 <code>i</code> 满足 <code>n % i == 0</code> ，那么我们就说正整数 <code>i</code> 是整数 <code>n</code> 的因子。</p>
|
||||
|
||||
<p>考虑整数 <code>n</code> 的所有因子，将它们 <strong>升序排列</strong> 。请你返回第 <code>k</code> 个因子。如果 <code>n</code> 的因子数少于 <code>k</code> ，请你返回 <strong>-1</strong> 。</p>
|
||||
<p>考虑整数 <code>n</code> 的所有因子，将它们 <strong>升序排列</strong> 。请你返回第 <code>k</code> 个因子。如果 <code>n</code> 的因子数少于 <code>k</code> ，请你返回 <code>-1</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -37,3 +37,9 @@
|
||||
<ul>
|
||||
<li><code>1 <= k <= n <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<p>你可以设计时间复杂度小于 O(n) 的算法来解决此问题吗？</p>
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>Alice 手中有一把牌，她想要重新排列这些牌，分成若干组，使每一组的牌数都是 <code>groupSize</code> ，并且由 <code>groupSize</code> 张连续的牌组成。</p>
|
||||
|
||||
<p>给你一个整数数组 <code>hand</code> 其中 <code>hand[i]</code> 是写在第 <code>i</code> 张牌，和一个整数 <code>groupSize</code> 。如果她可能重新排列这些牌，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
<p>给你一个整数数组 <code>hand</code> 其中 <code>hand[i]</code> 是写在第 <code>i</code> 张牌上的<strong>数值</strong>。如果她可能重新排列这些牌，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -1,20 +1,22 @@
|
||||
<p>字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。 给定两个字符串，编写一个函数判定它们是否只需要一次(或者零次)编辑。</p>
|
||||
<p>字符串有三种编辑操作:插入一个英文字符、删除一个英文字符或者替换一个英文字符。 给定两个字符串，编写一个函数判定它们是否只需要一次(或者零次)编辑。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong>
|
||||
first = "pale"
|
||||
second = "ple"
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
first = "pale"
|
||||
second = "ple"
|
||||
<strong>输出:</strong> True</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong>
|
||||
first = "pales"
|
||||
second = "pal"
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
first = "pales"
|
||||
second = "pal"
|
||||
<strong>输出:</strong> False
|
||||
</pre>
|
||||
|
||||
@@ -1,35 +1,47 @@
|
||||
<p>给你一个包含 <code>n</code> 个整数的数组 <code>nums</code>，判断 <code>nums</code> 中是否存在三个元素 <em>a，b，c ，</em>使得 <em>a + b + c = </em>0 ？请你找出所有和为 <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> 。请</p>
|
||||
|
||||
<p>你返回所有和为 <code>0</code> 且不重复的三元组。</p>
|
||||
|
||||
<p><strong>注意：</strong>答案中不可以包含重复的三元组。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-1,0,1,2,-1,-4]
|
||||
<strong>输出：</strong>[[-1,-1,2],[-1,0,1]]
|
||||
<strong>解释：</strong>
|
||||
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
|
||||
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
|
||||
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
|
||||
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
|
||||
注意，输出的顺序和三元组的顺序并不重要。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = []
|
||||
<strong>输入：</strong>nums = [0,1,1]
|
||||
<strong>输出：</strong>[]
|
||||
<strong>解释：</strong>唯一可能的三元组和不为 0 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0]
|
||||
<strong>输出：</strong>[]
|
||||
<strong>输入：</strong>nums = [0,0,0]
|
||||
<strong>输出：</strong>[[0,0,0]]
|
||||
<strong>解释：</strong>唯一可能的三元组和为 0 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= nums.length <= 3000</code></li>
|
||||
<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>3 <= nums.length <= 3000</code></li>
|
||||
<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,41 +1,51 @@
|
||||
<p>给你一个数组 <code>nums</code> ，每次操作你可以选择 <code>nums</code> 中的任意一个元素并将它改成任意值。</p>
|
||||
<p>给你一个数组 <code>nums</code> 。</p>
|
||||
|
||||
<p>请你返回三次操作后， <code>nums</code> 中最大值与最小值的差的最小值。</p>
|
||||
<p>每次操作你可以选择 <code>nums</code> 中的任意一个元素并将它改成 <strong>任意值</strong> 。</p>
|
||||
|
||||
<p>在 <strong>执行最多三次移动后 </strong>，返回 <code>nums</code> 中最大值与最小值的最小差值。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [5,3,2,4]
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [5,3,2,4]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>将数组 [5,3,2,4] 变成 [<strong>2</strong>,<strong>2</strong>,2,<strong>2</strong>].
|
||||
最大值与最小值的差为 2-2 = 0 。</pre>
|
||||
<strong>解释：</strong>我们最多可以走 3 步。
|
||||
第一步，将 2 变为 3 。 nums 变成 [5,3,3,4] 。
|
||||
第二步，将 4 改为 3 。 nums 变成 [5,3,3,3] 。
|
||||
第三步，将 5 改为 3 。 nums 变成 [3,3,3,3] 。
|
||||
执行 3 次移动后，最小值和最大值之间的差值为 3 - 3 = 0 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [1,5,0,10,14]
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,5,0,10,14]
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>将数组 [1,5,0,10,14] 变成 [1,<strong>1</strong>,0,<strong>1</strong>,<strong>1</strong>] 。
|
||||
最大值与最小值的差为 1-0 = 1 。
|
||||
<strong>解释：</strong>我们最多可以走 3 步。
|
||||
第一步，将 5 改为 0 。 nums变成 [1,0,0,10,14] 。
|
||||
第二步，将 10 改为 0 。 nums变成 [1,0,0,0,14] 。
|
||||
第三步，将 14 改为 1 。 nums变成 [1,0,0,0,1] 。
|
||||
执行 3 步后，最小值和最大值之间的差值为 1 - 0 = 1 。
|
||||
可以看出，没有办法可以在 3 步内使差值变为0。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [6,6,0,1,1,4,6]
|
||||
<strong>输出：</strong>2
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>nums = [1,5,6,14,15]
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,100,20]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>我们最多可以走 3 步。
|
||||
第一步，将 100 改为 7 。 nums 变成 [3,7,20] 。
|
||||
第二步，将 20 改为 7 。 nums 变成 [3,7,7] 。
|
||||
第三步，将 3 改为 7 。 nums 变成 [7,7,7] 。
|
||||
执行 3 步后，最小值和最大值之间的差值是 7 - 7 = 0。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10^5</code></li>
|
||||
<li><code>-10^9 <= nums[i] <= 10^9</code></li>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -10,14 +10,19 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,1,2]
|
||||
<strong>输出：</strong>5
|
||||
<strong>解释：</strong>你可以用三个边长组成一个三角形:1 2 2。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,1]
|
||||
<strong>输入：</strong>nums = [1,2,1,10]
|
||||
<strong>输出：</strong>0
|
||||
</pre>
|
||||
<strong>解释：</strong>
|
||||
你不能用边长 1,1,2 来组成三角形。
|
||||
不能用边长 1,1,10 来构成三角形。
|
||||
不能用边长 1、2 和 10 来构成三角形。
|
||||
因为我们不能用任何三条边长来构成一个非零面积的三角形，所以我们返回 0。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
|
||||
@@ -10,20 +10,20 @@
|
||||
| recordDate | date |
|
||||
| temperature | int |
|
||||
+---------------+---------+
|
||||
id 是这个表的主键
|
||||
id 是该表具有唯一值的列。
|
||||
该表包含特定日期的温度信息</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>编写一个 SQL 查询，来查找与之前（昨天的）日期相比温度更高的所有日期的 <code>id</code> 。</p>
|
||||
<p>编写解决方案，找出与之前（昨天的）日期相比温度更高的所有日期的 <code>id</code> 。</p>
|
||||
|
||||
<p>返回结果 <strong>不要求顺序</strong> 。</p>
|
||||
<p>返回结果 <strong>无顺序要求</strong> 。</p>
|
||||
|
||||
<p>查询结果格式如下例。</p>
|
||||
<p>结果格式如下例子所示。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<code><strong>输入：</strong>
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
<p>给你一个 <code>n x n</code> 整数矩阵 <code>arr</code> ，请你返回 <strong>非零偏移下降路径</strong> 数字和的最小值。</p>
|
||||
<p>给你一个 <code>n x n</code> 整数矩阵 <code>grid</code> ，请你返回 <strong>非零偏移下降路径</strong> 数字和的最小值。</p>
|
||||
|
||||
<p><strong>非零偏移下降路径</strong> 定义为：从 <code>arr</code> 数组中的每一行选择一个数字，且按顺序选出来的数字中，相邻数字不在原数组的同一列。</p>
|
||||
<p><strong>非零偏移下降路径</strong> 定义为：从 <code>grid</code> 数组中的每一行选择一个数字，且按顺序选出来的数字中，相邻数字不在原数组的同一列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/falling-grid.jpg" style="width: 244px; height: 245px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>arr = [[1,2,3],[4,5,6],[7,8,9]]
|
||||
<strong>输入：</strong>grid = [[1,2,3],[4,5,6],[7,8,9]]
|
||||
<strong>输出：</strong>13
|
||||
<strong>解释：</strong>
|
||||
所有非零偏移下降路径包括：
|
||||
@@ -19,7 +19,7 @@
|
||||
下降路径中数字和最小的是 [1,5,7] ，所以答案是 13 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[7]]
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
<p>返回 <code>s</code> 字典序最小的子序列，该子序列包含 <code>s</code> 的所有不同字符，且只包含一次。</p>
|
||||
|
||||
<p><strong>注意：</strong>该题与 316 <a href="https://leetcode.com/problems/remove-duplicate-letters/">https://leetcode.com/problems/remove-duplicate-letters/</a> 相同</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -17,11 +15,15 @@
|
||||
<strong>输入：</strong><code>s = "cbacdcbc"</code>
|
||||
<strong>输出：</strong><code>"acdb"</code></pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s</code> 由小写英文字母组成</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>注意：</strong>该题与 316 <a href="https://leetcode.cn/problems/remove-duplicate-letters/">https://leetcode.cn/problems/remove-duplicate-letters/</a> 相同</p>
|
||||
|
||||
@@ -1,29 +1,25 @@
|
||||
<p>给定一个字符串 <code>s</code><strong> </strong>和一个字符串 <code>t</code> ，计算在 <code>s</code> 的子序列中 <code>t</code> 出现的个数。</p>
|
||||
<p>给你两个字符串 <code>s</code><strong> </strong>和 <code>t</code> ，统计并返回在 <code>s</code> 的 <strong>子序列</strong> 中 <code>t</code> 出现的个数，结果需要对 10<sup>9</sup> + 7 取模。</p>
|
||||
|
||||
<p>字符串的一个 <strong>子序列</strong> 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，<code>"ACE"</code> 是 <code>"ABCDE"</code> 的一个子序列，而 <code>"AEC"</code> 不是）</p>
|
||||
<p> </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>。
|
||||
如下所示, 有 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>
|
||||
|
||||
<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>。
|
||||
如下所示, 有 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>
|
||||
@@ -31,11 +27,11 @@
|
||||
<code>babg<strong><u>bag</u></strong></code>
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= s.length, t.length <= 1000</code></li>
|
||||
<li><code>1 <= s.length, t.length <= 1000</code></li>
|
||||
<li><code>s</code> 和 <code>t</code> 由英文字母组成</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
<p>一个机器人位于一个 <code>m x n</code><em> </em>网格的左上角 （起始点在下图中标记为 “Start” ）。</p>
|
||||
<p>一个机器人位于一个 <code>m x n</code><em> </em>网格的左上角 （起始点在下图中标记为 “Start” ）。</p>
|
||||
|
||||
<p>机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。</p>
|
||||
|
||||
<p>问总共有多少条不同的路径？</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img src="https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png" />
|
||||
<img src="https://pic.leetcode.cn/1697422740-adxmsI-image.png" style="width: 400px; height: 183px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>m = 3, n = 7
|
||||
<strong>输出：</strong>28</pre>
|
||||
@@ -19,9 +19,9 @@
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>
|
||||
从左上角开始，总共有 3 条路径可以到达右下角。
|
||||
1. 向右 -> 向下 -> 向下
|
||||
2. 向下 -> 向下 -> 向右
|
||||
3. 向下 -> 向右 -> 向下
|
||||
1. 向右 -> 向下 -> 向下
|
||||
2. 向下 -> 向下 -> 向右
|
||||
3. 向下 -> 向右 -> 向下
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
@@ -37,11 +37,11 @@
|
||||
<strong>输入：</strong>m = 3, n = 3
|
||||
<strong>输出：</strong>6</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= m, n <= 100</code></li>
|
||||
<li><code>1 <= m, n <= 100</code></li>
|
||||
<li>题目数据保证答案小于等于 <code>2 * 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
<p>给定两个整数 <code>a</code> 和 <code>b</code> ，返回 <strong>任意</strong> 字符串 <code>s</code> ，要求满足：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>s</code> 的长度为 <code>a + b</code>，且正好包含<code><font color="#c7254e"><font face="Menlo, Monaco, Consolas, Courier New, monospace"><span style="font-size:12.600000381469727px"><span style="caret-color:#c7254e"><span style="background-color:#f9f2f4">a</span></span></span></font></font></code> 个 <code>'a'</code> 字母与 <code><font color="#c7254e"><font face="Menlo, Monaco, Consolas, Courier New, monospace"><span style="font-size:12.600000381469727px"><span style="caret-color:#c7254e"><span style="background-color:#f9f2f4">b</span></span></span></font></font></code> 个 <code>'b'</code> 字母；</li>
|
||||
<li><code>s</code> 的长度为 <code>a + b</code>，且正好包含 <code>a</code> 个 <code>'a'</code> 字母与 <code>b</code> 个 <code>'b'</code> 字母；</li>
|
||||
<li>子串 <code>'aaa'</code> 没有出现在 <code>s</code> 中；</li>
|
||||
<li>子串 <code>'bbb'</code> 没有出现在 <code>s</code> 中。</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>给定一个正整数 <code>n</code> ，返回范围在 <code>[0, n]</code> 都非负整数中，其二进制表示不包含 <strong>连续的 1 </strong>的个数。</p>
|
||||
<p>给定一个正整数 <code>n</code> ，请你统计在 <code>[0, n]</code> 范围的非负整数中，有多少个整数的二进制表示中不存在 <strong>连续的 1 </strong>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -8,14 +8,14 @@
|
||||
<strong>输入:</strong> n = 5
|
||||
<strong>输出:</strong> 5
|
||||
<strong>解释:</strong>
|
||||
下面是带有相应二进制表示的非负整数<= 5：
|
||||
下面列出范围在 [0, 5] 的非负整数与其对应的二进制表示：
|
||||
0 : 0
|
||||
1 : 1
|
||||
2 : 10
|
||||
3 : 11
|
||||
4 : 100
|
||||
5 : 101
|
||||
其中，只有整数3违反规则（有两个连续的1），其他5个满足规则。</pre>
|
||||
其中，只有整数 3 违反规则（有两个连续的 1 ），其他 5 个满足规则。</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
<p>给你一个整数 <code>n</code> ，请你找出并返回第 <code>n</code> 个 <strong>丑数</strong> 。</p>
|
||||
|
||||
<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> 的正整数。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -20,10 +20,10 @@
|
||||
<strong>解释：</strong>1 通常被视为丑数。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1690</code></li>
|
||||
<li><code>1 <= n <= 1690</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,18 +1,24 @@
|
||||
<p>我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。</p>
|
||||
<p>给你一个整数 <code>n</code> ，请你找出并返回第 <code>n</code> 个 丑数 。</p>
|
||||
|
||||
<p><strong>说明：</strong>丑数是只包含质因数 2、3 和/或 5 的正整数；1 是丑数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> n = 10
|
||||
<pre>
|
||||
<strong>输入:</strong> n = 10
|
||||
<strong>输出:</strong> 12
|
||||
<strong>解释: </strong><code>1, 2, 3, 4, 5, 6, 8, 9, 10, 12</code> 是前 10 个丑数。</pre>
|
||||
|
||||
<p><strong>说明: </strong> </p>
|
||||
<p><b>提示：</b> </p>
|
||||
|
||||
<ol>
|
||||
<li><code>1</code> 是丑数。</li>
|
||||
<li><code>n</code> <strong>不超过</strong>1690。</li>
|
||||
</ol>
|
||||
<ul>
|
||||
<li><code>1 <= n <=<b> </b>1690</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>注意：本题与主站 264 题相同：<a href="https://leetcode-cn.com/problems/ugly-number-ii/">https://leetcode-cn.com/problems/ugly-number-ii/</a></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -7,8 +7,8 @@
|
||||
| employee_id | int |
|
||||
| name | varchar |
|
||||
+-------------+---------+
|
||||
employee_id 是这个表的主键。
|
||||
每一行表示雇员的id 和他的姓名。
|
||||
employee_id 是该表中具有唯一值的列。
|
||||
每一行表示雇员的 id 和他的姓名。
|
||||
</pre>
|
||||
|
||||
<p>表: <code>Salaries</code></p>
|
||||
@@ -20,20 +20,20 @@ employee_id 是这个表的主键。
|
||||
| employee_id | int |
|
||||
| salary | int |
|
||||
+-------------+---------+
|
||||
employee_id is 这个表的主键。
|
||||
每一行表示雇员的id 和他的薪水。
|
||||
employee_id 是该表中具有唯一值的列。
|
||||
每一行表示雇员的 id 和他的薪水。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>写出一个查询语句，找到所有 <strong>丢失信息</strong> 的雇员id。当满足下面一个条件时，就被认为是雇员的信息丢失：</p>
|
||||
<p>编写解决方案，找到所有 <strong>丢失信息</strong> 的雇员 id。当满足下面一个条件时，就被认为是雇员的信息丢失：</p>
|
||||
|
||||
<ul>
|
||||
<li>雇员的 <strong>姓名</strong> 丢失了，或者</li>
|
||||
<li>雇员的 <strong>薪水信息</strong> 丢失了，或者</li>
|
||||
<li>雇员的 <strong>薪水信息</strong> 丢失了</li>
|
||||
</ul>
|
||||
|
||||
<p>返回这些雇员的id <code>employee_id</code> ， <strong>从小到大排序 </strong>。</p>
|
||||
<p>返回这些雇员的 id <code>employee_id</code> ， <strong>从小到大排序 </strong>。</p>
|
||||
|
||||
<p>查询结果格式如下面的例子所示。</p>
|
||||
|
||||
@@ -67,6 +67,6 @@ Salaries table:
|
||||
| 2 |
|
||||
+-------------+
|
||||
<strong>解释：</strong>
|
||||
雇员1，2，4，5 都工作在这个公司。
|
||||
1号雇员的姓名丢失了。
|
||||
2号雇员的薪水信息丢失了。</pre>
|
||||
雇员 1，2，4，5 都在这个公司工作。
|
||||
1 号雇员的姓名丢失了。
|
||||
2 号雇员的薪水信息丢失了。</pre>
|
||||
|
||||
@@ -1,30 +1,30 @@
|
||||
给定两个 promise 对象 <code>promise1</code> 和 <code>promise2</code>，返回一个新的 promise。<code>promise1</code> 和 <code>promise2</code> 都会被解析为一个数字。返回的 Promise 应该解析为这两个数字的和。
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20)),
|
||||
promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60))
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>两个输入的 Promise 分别解析为值 2 和 5。返回的 Promise 应该解析为 2 + 5 = 7。返回的 Promise 解析的时间不作为判断条件。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50)),
|
||||
promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30))
|
||||
<b>输出：</b>-2
|
||||
<b>解释：</b>两个输入的 Promise 分别解析为值 10 和 -12。返回的 Promise 应该解析为 10 + -12 = -2。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>promise1 和 promise2 都是被解析为一个数字的 promise 对象</code></li>
|
||||
</ul>
|
||||
给定两个 promise 对象 <code>promise1</code> 和 <code>promise2</code>，返回一个新的 promise。<code>promise1</code> 和 <code>promise2</code> 都会被解析为一个数字。返回的 Promise 应该解析为这两个数字的和。
|
||||
<p> </p>
|
||||
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20)),
|
||||
promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60))
|
||||
<b>输出：</b>7
|
||||
<b>解释：</b>两个输入的 Promise 分别解析为值 2 和 5。返回的 Promise 应该解析为 2 + 5 = 7。返回的 Promise 解析的时间不作为判断条件。
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50)),
|
||||
promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30))
|
||||
<b>输出：</b>-2
|
||||
<b>解释：</b>两个输入的 Promise 分别解析为值 10 和 -12。返回的 Promise 应该解析为 10 + -12 = -2。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>promise1 和 promise2</code> 都是被解析为一个数字的 promise 对象</li>
|
||||
</ul>
|
||||
@@ -44,9 +44,9 @@
|
||||
<p><strong>点积：</strong></p>
|
||||
|
||||
<pre>
|
||||
定义 <code><strong>a</strong> = [<em>a</em><sub>1</sub>, <em>a</em><sub>2</sub>,…, <em>a</em><sub><em>n</em></sub>]</code> 和<strong> <code>b</code></strong><code> = [<em>b</em><sub>1</sub>, <em>b</em><sub>2</sub>,…, <em>b</em><sub><em>n</em></sub>]</code> 的点积为：
|
||||
定义 <code><strong>a</strong> = [<em>a</em><sub>1</sub>, <em>a</em><sub>2</sub>,…, <em>a</em><sub><em>n</em></sub>]</code> 和<strong> <code>b</code></strong><code> = [<em>b</em><sub>1</sub>, <em>b</em><sub>2</sub>,…, <em>b</em><sub><em>n</em></sub>]</code> 的点积为：
|
||||
|
||||
<img alt="\mathbf{a}\cdot \mathbf{b} = \sum_{i=1}^n a_ib_i = a_1b_1 + a_2b_2 + \cdots + a_nb_n " class="tex" src="http://upload.wikimedia.org/math/c/3/2/c329bf86e747d74f55ed2e17c36fd83f.png" />
|
||||
<img alt="\mathbf{a}\cdot \mathbf{b} = \sum_{i=1}^n a_ib_i = a_1b_1 + a_2b_2 + \cdots + a_nb_n " class="tex" src="https://pic.leetcode-cn.com/1666164309-PBJMQp-image.png" />
|
||||
|
||||
这里的 <strong>Σ</strong> 指示总和符号。
|
||||
这里的 <strong>Σ</strong> 指示总和符号。
|
||||
</pre>
|
||||
|
||||
@@ -1,20 +1,15 @@
|
||||
<p>给出非负整数数组 <code>A</code> ，返回两个非重叠（连续）子数组中元素的最大和，子数组的长度分别为 <code>L</code> 和 <code>M</code>。（这里需要澄清的是，长为 L 的子数组可以出现在长为 M 的子数组之前或之后。）</p>
|
||||
<p>给你一个整数数组 <code>nums</code> 和两个整数 <code>firstLen</code> 和 <code>secondLen</code>，请你找出并返回两个非重叠<strong> 子数组 </strong>中元素的最大和<em>，</em>长度分别为 <code>firstLen</code> 和 <code>secondLen</code> 。</p>
|
||||
|
||||
<p>从形式上看，返回最大的 <code>V</code>，而 <code>V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1])</code> 并满足下列条件之一：</p>
|
||||
<p>长度为 <code>firstLen</code> 的子数组可以出现在长为 <code>secondLen</code> 的子数组之前或之后，但二者必须是不重叠的。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= i < i + L - 1 < j < j + M - 1 < A.length</code>, <strong>或</strong></li>
|
||||
<li><code>0 <= j < j + M - 1 < i < i + L - 1 < A.length</code>.</li>
|
||||
</ul>
|
||||
<p>子数组是数组的一个 <strong>连续</strong> 部分。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2
|
||||
<strong>输入：</strong>nums = [0,6,5,2,2,5,1,9,4], firstLen = 1, secondLen = 2
|
||||
<strong>输出：</strong>20
|
||||
<strong>解释：</strong>子数组的一种选择中，[9] 长度为 1，[6,5] 长度为 2。
|
||||
</pre>
|
||||
@@ -22,7 +17,7 @@
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>A = [3,8,1,3,2,1,8,9,0], L = 3, M = 2
|
||||
<strong>输入：</strong>nums = [3,8,1,3,2,1,8,9,0], firstLen = 3, secondLen = 2
|
||||
<strong>输出：</strong>29
|
||||
<strong>解释：</strong>子数组的一种选择中，[3,8,1] 长度为 3，[8,9] 长度为 2。
|
||||
</pre>
|
||||
@@ -30,17 +25,18 @@
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>A = [2,1,5,6,0,9,5,0,3,8], L = 4, M = 3
|
||||
<strong>输入：</strong>nums = [2,1,5,6,0,9,5,0,3,8], firstLen = 4, secondLen = 3
|
||||
<strong>输出：</strong>31
|
||||
<strong>解释：</strong>子数组的一种选择中，[5,6,0,9] 长度为 4，[0,3,8] 长度为 3。</pre>
|
||||
<strong>解释：</strong>子数组的一种选择中，[5,6,0,9] 长度为 4，[0,3,8] 长度为 3。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>L >= 1</code></li>
|
||||
<li><code>M >= 1</code></li>
|
||||
<li><code>L + M <= A.length <= 1000</code></li>
|
||||
<li><code>0 <= A[i] <= 1000</code></li>
|
||||
<li><code>1 <= firstLen, secondLen <= 1000</code></li>
|
||||
<li><code>2 <= firstLen + secondLen <= 1000</code></li>
|
||||
<li><code>firstLen + secondLen <= nums.length <= 1000</code></li>
|
||||
<li><code>0 <= nums[i] <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -35,11 +35,11 @@
|
||||
<ul>
|
||||
<li><code>2 <= numbers.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>-1000 <= numbers[i] <= 1000</code></li>
|
||||
<li><code>numbers</code> 按 <strong>递增顺序</strong> 排列</li>
|
||||
<li><code>numbers</code> 按 <strong>非递减顺序</strong> 排列</li>
|
||||
<li><code>-1000 <= target <= 1000</code></li>
|
||||
<li>仅存在一个有效答案</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>注意：本题与主站 167 题相似（下标起点不同）：<a href="https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/">https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/</a></p>
|
||||
<p>注意：本题与主站 167 题相似（下标起点不同）：<a href="https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted/">https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted/</a></p>
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>给定一个二叉搜索树 <code>root</code> 和一个目标结果 <code>k</code>，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 <code>true</code>。</p>
|
||||
<p>给定一个二叉搜索树 <code>root</code> 和一个目标结果 <code>k</code>，如果二叉搜索树中存在两个元素且它们的和等于给定的目标结果，则返回 <code>true</code>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -23,6 +23,6 @@
|
||||
<ul>
|
||||
<li>二叉树的节点个数的范围是 <code>[1, 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code></li>
|
||||
<li><code>root</code> 为二叉搜索树</li>
|
||||
<li>题目数据保证，输入的 <code>root</code> 是一棵 <strong>有效</strong> 的二叉搜索树</li>
|
||||
<li><code>-10<sup>5</sup> <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,7,11,15], target = 9
|
||||
@@ -14,14 +14,14 @@
|
||||
<strong>解释：</strong>因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,2,4], target = 6
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,3], target = 6
|
||||
@@ -39,4 +39,6 @@
|
||||
<li><strong>只会存在一个有效答案</strong></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你可以想出一个时间复杂度小于 <code>O(n<sup>2</sup>)</code> 的算法吗？</p>
|
||||
|
||||
@@ -1,29 +1,32 @@
|
||||
<p>给定两个整数，被除数 <code>dividend</code> 和除数 <code>divisor</code>。将两数相除，要求不使用乘法、除法和 mod 运算符。</p>
|
||||
<p>给你两个整数，被除数 <code>dividend</code> 和除数 <code>divisor</code>。将两数相除，要求 <strong>不使用</strong> 乘法、除法和取余运算。</p>
|
||||
|
||||
<p>返回被除数 <code>dividend</code> 除以除数 <code>divisor</code> 得到的商。</p>
|
||||
<p>整数除法应该向零截断，也就是截去（<code>truncate</code>）其小数部分。例如，<code>8.345</code> 将被截断为 <code>8</code> ，<code>-2.7335</code> 将被截断至 <code>-2</code> 。</p>
|
||||
|
||||
<p>整数除法的结果应当截去（<code>truncate</code>）其小数部分，例如：<code>truncate(8.345) = 8</code> 以及 <code>truncate(-2.7335) = -2</code></p>
|
||||
<p>返回被除数 <code>dividend</code> 除以除数 <code>divisor</code> 得到的 <strong>商</strong> 。</p>
|
||||
|
||||
<p><strong>注意：</strong>假设我们的环境只能存储 <strong>32 位</strong> 有符号整数，其数值范围是 <code>[−2<sup>31</sup>, 2<sup>31 </sup>− 1]</code> 。本题中，如果商 <strong>严格大于</strong> <code>2<sup>31 </sup>− 1</code> ，则返回 <code>2<sup>31 </sup>− 1</code> ；如果商 <strong>严格小于</strong> <code>-2<sup>31</sup></code> ，则返回 <code>-2<sup>31</sup></code><sup> </sup>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> dividend = 10, divisor = 3
|
||||
<pre>
|
||||
<strong>输入:</strong> dividend = 10, divisor = 3
|
||||
<strong>输出:</strong> 3
|
||||
<strong>解释: </strong>10/3 = truncate(3.33333..) = truncate(3) = 3</pre>
|
||||
<strong>解释: </strong>10/3 = 3.33333.. ，向零截断后得到 3 。</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> dividend = 7, divisor = -3
|
||||
<pre>
|
||||
<strong>输入:</strong> dividend = 7, divisor = -3
|
||||
<strong>输出:</strong> -2
|
||||
<strong>解释:</strong> 7/-3 = truncate(-2.33333..) = -2</pre>
|
||||
<strong>解释:</strong> 7/-3 = -2.33333.. ，向零截断后得到 -2 。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>被除数和除数均为 32 位有符号整数。</li>
|
||||
<li>除数不为 0。</li>
|
||||
<li>假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2<sup>31</sup>, 2<sup>31 </sup>− 1]。本题中，如果除法结果溢出，则返回 2<sup>31 </sup>− 1。</li>
|
||||
<li><code>-2<sup>31</sup> <= dividend, divisor <= 2<sup>31</sup> - 1</code></li>
|
||||
<li><code>divisor != 0</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,17 +1,24 @@
|
||||
<p>给定一个字符串 <code>s</code><strong> </strong>和一些 <strong>长度相同</strong> 的单词 <code>words</code><strong> 。</strong>找出 <code>s</code><strong> </strong>中恰好可以由 <code>words</code><strong> </strong>中所有单词串联形成的子串的起始位置。</p>
|
||||
<p>给定一个字符串 <code>s</code><strong> </strong>和一个字符串数组 <code>words</code><strong>。</strong> <code>words</code> 中所有字符串 <strong>长度相同</strong>。</p>
|
||||
|
||||
<p>注意子串要与 <code>words</code><strong> </strong>中的单词完全匹配，<strong>中间不能有其他字符 </strong>，但不需要考虑 <code>words</code><strong> </strong>中单词串联的顺序。</p>
|
||||
<p> <code>s</code><strong> </strong>中的 <strong>串联子串</strong> 是指一个包含 <code>words</code> 中所有字符串以任意顺序排列连接起来的子串。</p>
|
||||
|
||||
<p> </p>
|
||||
<ul>
|
||||
<li>例如，如果 <code>words = ["ab","cd","ef"]</code>， 那么 <code>"abcdef"</code>， <code>"abefcd"</code>，<code>"cdabef"</code>， <code>"cdefab"</code>，<code>"efabcd"</code>， 和 <code>"efcdab"</code> 都是串联子串。 <code>"acdbef"</code> 不是串联子串，因为他不是任何 <code>words</code> 排列的连接。</li>
|
||||
</ul>
|
||||
|
||||
<p>返回所有串联子串在 <code>s</code><strong> </strong>中的开始索引。你可以以 <strong>任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "barfoothefoobarman", words = ["foo","bar"]
|
||||
<strong>输出：</strong><code>[0,9]</code>
|
||||
<strong>解释：</strong>
|
||||
从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。
|
||||
输出的顺序不重要, [9,0] 也是有效答案。
|
||||
<strong>解释：</strong>因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
|
||||
子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
|
||||
子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
|
||||
输出顺序无关紧要。返回 [9,0] 也是可以的。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
@@ -19,6 +26,9 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
|
||||
<code><strong>输出：</strong>[]</code>
|
||||
<strong>解释：</strong>因为<strong> </strong>words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
|
||||
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
|
||||
所以我们返回一个空数组。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
@@ -26,16 +36,18 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
|
||||
<strong>输出：</strong>[6,9,12]
|
||||
</pre>
|
||||
<strong>解释：</strong>因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
|
||||
子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
|
||||
子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
|
||||
子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>s</code> 由小写英文字母组成</li>
|
||||
<li><code>1 <= words.length <= 5000</code></li>
|
||||
<li><code>1 <= words[i].length <= 30</code></li>
|
||||
<li><code>words[i]</code> 由小写英文字母组成</li>
|
||||
<li><code>1 <= s.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= words.length <= 5000</code></li>
|
||||
<li><code>1 <= words[i].length <= 30</code></li>
|
||||
<li><code>words[i]</code> 和 <code>s</code> 由小写英文字母组成</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
<p>给你一个由数字和运算符组成的字符串 <code>expression</code> ，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以 <strong>按任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p>生成的测试用例满足其对应输出值符合 32 位整数范围，不同结果的数量不超过 <code>10<sup>4</sup></code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -1,37 +1,36 @@
|
||||
<p>几乎每一个人都用 <a href="https://baike.baidu.com/item/%E4%B9%98%E6%B3%95%E8%A1%A8">乘法表</a>。但是你能在乘法表中快速找到第<code>k</code>小的数字吗？</p>
|
||||
<p>几乎每一个人都用 <a href="https://baike.baidu.com/item/%E4%B9%98%E6%B3%95%E8%A1%A8">乘法表</a>。但是你能在乘法表中快速找到第 <code>k</code> 小的数字吗？</p>
|
||||
|
||||
<p>给定高度<code>m</code> 、宽度<code>n</code> 的一张 <code>m * n</code>的乘法表，以及正整数<code>k</code>，你需要返回表中第<code>k</code> 小的数字。</p>
|
||||
<p>乘法表是大小为 <code>m x n</code> 的一个整数矩阵，其中 <code>mat[i][j] == i * j</code>（下标从 <strong>1</strong> 开始）。</p>
|
||||
|
||||
<p><strong>例 1：</strong></p>
|
||||
<p>给你三个整数 <code>m</code>、<code>n</code> 和 <code>k</code>，请你在大小为 <code>m x n</code> 的乘法表中，找出并返回第 <code>k</code> 小的数字。</p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/05/02/multtable1-grid.jpg" style="width: 500px; height: 254px;" />
|
||||
<pre>
|
||||
<strong>输入:</strong> m = 3, n = 3, k = 5
|
||||
<strong>输出:</strong> 3
|
||||
<strong>解释:</strong>
|
||||
乘法表:
|
||||
1 2 3
|
||||
2 4 6
|
||||
3 6 9
|
||||
|
||||
第5小的数字是 3 (1, 2, 2, 3, 3).
|
||||
<strong>输入：</strong>m = 3, n = 3, k = 5
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>第 5 小的数字是 3 。
|
||||
</pre>
|
||||
|
||||
<p><strong>例 2：</strong></p>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/05/02/multtable2-grid.jpg" style="width: 493px; height: 293px;" />
|
||||
<pre>
|
||||
<strong>输入:</strong> m = 2, n = 3, k = 6
|
||||
<strong>输出:</strong> 6
|
||||
<strong>解释:</strong>
|
||||
乘法表:
|
||||
1 2 3
|
||||
2 4 6
|
||||
|
||||
第6小的数字是 6 (1, 2, 2, 3, 4, 6).
|
||||
<strong>输入：</strong>m = 2, n = 3, k = 6
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>第 6 小的数字是 6 。
|
||||
</pre>
|
||||
|
||||
<p><strong>注意：</strong></p>
|
||||
<p> </p>
|
||||
|
||||
<ol>
|
||||
<li><code>m</code> 和 <code>n</code> 的范围在 [1, 30000] 之间。</li>
|
||||
<li><code>k</code> 的范围在 [1, m * n] 之间。</li>
|
||||
</ol>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= m, n <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= k <= m * n</code></li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -1,19 +1,19 @@
|
||||
<p>给定一个整数数组 <code>prices</code> ，它的第<em> </em><code>i</code> 个元素 <code>prices[i]</code> 是一支给定的股票在第 <code>i</code><em> </em>天的价格。</p>
|
||||
<p>给你一个整数数组 <code>prices</code> 和一个整数 <code>k</code> ，其中 <code>prices[i]</code> 是某支给定的股票在第 <code>i</code><em> </em>天的价格。</p>
|
||||
|
||||
<p>设计一个算法来计算你所能获取的最大利润。你最多可以完成 <strong>k</strong> 笔交易。</p>
|
||||
<p>设计一个算法来计算你所能获取的最大利润。你最多可以完成 <code>k</code> 笔交易。也就是说，你最多可以买 <code>k</code> 次，卖 <code>k</code> 次。</p>
|
||||
|
||||
<p><strong>注意：</strong>你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>k = 2, prices = [2,4,1]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>k = 2, prices = [3,2,6,5,0,3]
|
||||
@@ -21,12 +21,12 @@
|
||||
<strong>解释：</strong>在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
|
||||
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= k <= 100</code></li>
|
||||
<li><code>0 <= prices.length <= 1000</code></li>
|
||||
<li><code>0 <= prices[i] <= 1000</code></li>
|
||||
<li><code>1 <= k <= 100</code></li>
|
||||
<li><code>1 <= prices.length <= 1000</code></li>
|
||||
<li><code>0 <= prices[i] <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -12,7 +12,9 @@
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["EventEmitter", "emit", "subscribe", "subscribe", "emit"], values = [[], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent"]]
|
||||
<b>输入：
|
||||
</b>actions = ["EventEmitter", "emit", "subscribe", "subscribe", "emit"],
|
||||
values = [[], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent"]]
|
||||
<b>输出：</b>[[],["emitted",[]],["subscribed"],["subscribed"],["emitted",[5,6]]]
|
||||
<b>解释：</b>
|
||||
const emitter = new EventEmitter();
|
||||
@@ -25,7 +27,9 @@ emitter.emit("firstEvent"); // [5, 6], 返回 cb1 和 cb2 的输出
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["EventEmitter", "subscribe", "emit", "emit"], values = [[], ["firstEvent", "function cb1(...args) { return args.join(','); }"], ["firstEvent", [1,2,3]], ["firstEvent", [3,4,6]]]
|
||||
<b>输入：
|
||||
</b>actions = ["EventEmitter", "subscribe", "emit", "emit"],
|
||||
values = [[], ["firstEvent", "function cb1(...args) { return args.join(','); }"], ["firstEvent", [1,2,3]], ["firstEvent", [3,4,6]]]
|
||||
<b>输出：</b>[[],["subscribed"],["emitted",["1,2,3"]],["emitted",["3,4,6"]]]
|
||||
<strong>解释：</strong>注意 emit 方法应该能够接受一个可选的参数数组。
|
||||
|
||||
@@ -38,7 +42,9 @@ emitter.emit("firstEvent", [3, 4, 6]); // ["3,4,6"]
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["EventEmitter", "subscribe", "emit", "unsubscribe", "emit"], values = [[], ["firstEvent", "(...args) => args.join(',')"], ["firstEvent", [1,2,3]], [0], ["firstEvent", [4,5,6]]]
|
||||
<b>输入：
|
||||
</b>actions = ["EventEmitter", "subscribe", "emit", "unsubscribe", "emit"],
|
||||
values = [[], ["firstEvent", "(...args) => args.join(',')"], ["firstEvent", [1,2,3]], [0], ["firstEvent", [4,5,6]]]
|
||||
<b>输出：</b>[[],["subscribed"],["emitted",["1,2,3"]],["unsubscribed",0],["emitted",[]]]
|
||||
<b>解释：</b>
|
||||
const emitter = new EventEmitter();
|
||||
@@ -48,6 +54,20 @@ sub.unsubscribe(); // undefined
|
||||
emitter.emit("firstEvent", [4, 5, 6]); // [], 没有订阅者
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<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>
|
||||
const emitter = new EventEmitter();
|
||||
const sub1 = emitter.subscribe("firstEvent", x => x + 1);
|
||||
const sub2 = emitter.subscribe("firstEvent", x => x + 2);
|
||||
sub1.unsubscribe(); // undefined
|
||||
emitter.emit("firstEvent", [5]); // [7]</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
<b>输出：</b>[2,1,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/12/tree2.jpg" style="height: 179px; width: 250px;" />
|
||||
<pre>
|
||||
<b>输入：</b>root = [4,2,7,1,3], val = 5
|
||||
@@ -25,7 +25,7 @@
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>数中节点数在 <code>[1, 5000]</code> 范围内</li>
|
||||
<li>树中节点数在 <code>[1, 5000]</code> 范围内</li>
|
||||
<li><code>1 <= Node.val <= 10<sup>7</sup></code></li>
|
||||
<li><code>root</code> 是二叉搜索树</li>
|
||||
<li><code>1 <= val <= 10<sup>7</sup></code></li>
|
||||
|
||||
@@ -40,3 +40,5 @@
|
||||
</ul>
|
||||
|
||||
<p>注意：本题与主站 113 题相同：<a href="https://leetcode-cn.com/problems/path-sum-ii/">https://leetcode-cn.com/problems/path-sum-ii/</a></p>
|
||||
|
||||
<p> </p>
|
||||
@@ -1,31 +1,31 @@
|
||||
<p><strong>路径</strong> 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 <strong>至多出现一次</strong> 。该路径<strong> 至少包含一个 </strong>节点，且不一定经过根节点。</p>
|
||||
<p>二叉树中的<strong> 路径</strong> 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 <strong>至多出现一次</strong> 。该路径<strong> 至少包含一个 </strong>节点，且不一定经过根节点。</p>
|
||||
|
||||
<p><strong>路径和</strong> 是路径中各节点值的总和。</p>
|
||||
|
||||
<p>给你一个二叉树的根节点 <code>root</code> ，返回其 <strong>最大路径和</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg" style="width: 322px; height: 182px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3]
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6</pre>
|
||||
<strong>解释：</strong>最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [-10,9,20,null,null,15,7]
|
||||
<strong>输出：</strong>42
|
||||
<strong>解释：</strong>最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42
|
||||
<strong>解释：</strong>最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目范围是 <code>[1, 3 * 10<sup>4</sup>]</code></li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,66 +1,46 @@
|
||||
<p>给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与<strong>满二叉树（full binary tree）</strong>结构相同，但一些节点为空。</p>
|
||||
<p>给你一棵二叉树的根节点 <code>root</code> ，返回树的 <strong>最大宽度</strong> 。</p>
|
||||
|
||||
<p>每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的<code>null</code>节点也计入长度）之间的长度。</p>
|
||||
<p>树的 <strong>最大宽度</strong> 是所有层中最大的 <strong>宽度</strong> 。</p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p>每一层的 <strong>宽度</strong> 被定义为该层最左和最右的非空节点（即，两个端点）之间的长度。将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 <code>null</code> 节点，这些 <code>null</code> 节点也计入长度。</p>
|
||||
|
||||
<p>题目数据保证答案将会在 <strong>32 位</strong> 带符号整数范围内。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/05/03/width1-tree.jpg" style="width: 359px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
|
||||
1
|
||||
/ \
|
||||
3 2
|
||||
/ \ \
|
||||
5 3 9
|
||||
|
||||
<strong>输出:</strong> 4
|
||||
<strong>解释:</strong> 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。
|
||||
<strong>输入：</strong>root = [1,3,2,5,3,null,9]
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>最大宽度出现在树的第 3 层，宽度为 4 (5,3,null,9) 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/03/14/maximum-width-of-binary-tree-v3.jpg" style="width: 442px; height: 422px;" />
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
|
||||
1
|
||||
/
|
||||
3
|
||||
/ \
|
||||
5 3
|
||||
|
||||
<strong>输出:</strong> 2
|
||||
<strong>解释:</strong> 最大值出现在树的第 3 层，宽度为 2 (5,3)。
|
||||
<strong>输入：</strong>root = [1,3,2,5,null,null,9,6,null,7]
|
||||
<strong>输出：</strong>7
|
||||
<strong>解释：</strong>最大宽度出现在树的第 4 层，宽度为 7 (6,null,null,null,null,null,7) 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/05/03/width3-tree.jpg" style="width: 289px; height: 299px;" />
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
|
||||
1
|
||||
/ \
|
||||
3 2
|
||||
/
|
||||
5
|
||||
|
||||
<strong>输出:</strong> 2
|
||||
<strong>解释:</strong> 最大值出现在树的第 2 层，宽度为 2 (3,2)。
|
||||
<strong>输入：</strong>root = [1,3,2,5]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>最大宽度出现在树的第 2 层，宽度为 2 (3,2) 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4:</strong></p>
|
||||
<p> </p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
1
|
||||
/ \
|
||||
3 2
|
||||
/ \
|
||||
5 9
|
||||
/ \
|
||||
6 7
|
||||
<strong>输出:</strong> 8
|
||||
<strong>解释:</strong> 最大值出现在树的第 4 层，宽度为 8 (6,null,null,null,null,null,null,7)。
|
||||
</pre>
|
||||
|
||||
<p><strong>注意:</strong> 答案在32位有符号整数的表示范围内。</p>
|
||||
<ul>
|
||||
<li>树中节点的数目范围是 <code>[1, 3000]</code></li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -1,33 +1,42 @@
|
||||
「力扣嘉年华」的中心广场放置了一个巨型的二叉树形状的装饰树。每个节点上均有一盏灯和三个开关。节点值为 `0` 表示灯处于「关闭」状态，节点值为 `1` 表示灯处于「开启」状态。每个节点上的三个开关各自功能如下：
|
||||
- 开关 `1`：切换当前节点的灯的状态；
|
||||
- 开关 `2`：切换 **以当前节点为根** 的子树中，所有节点上的灯的状态，；
|
||||
- 开关 `3`：切换 **当前节点及其左右子节点**（若存在的话） 上的灯的状态；
|
||||
<p>「力扣嘉年华」的中心广场放置了一个巨型的二叉树形状的装饰树。每个节点上均有一盏灯和三个开关。节点值为 <code>0</code> 表示灯处于「关闭」状态，节点值为 <code>1</code> 表示灯处于「开启」状态。每个节点上的三个开关各自功能如下：</p>
|
||||
|
||||
给定该装饰的初始状态 `root`，请返回最少需要操作多少次开关，可以关闭所有节点的灯。
|
||||
<ul>
|
||||
<li>开关 <code>1</code>：切换当前节点的灯的状态；</li>
|
||||
<li>开关 <code>2</code>：切换 <strong>以当前节点为根</strong> 的子树中，所有节点上的灯的状态；</li>
|
||||
<li>开关 <code>3</code>：切换 <strong>当前节点及其左右子节点</strong>（若存在的话） 上的灯的状态；</li>
|
||||
</ul>
|
||||
|
||||
**示例 1：**
|
||||
>输入：`root = [1,1,0,null,null,null,1]`
|
||||
>
|
||||
>输出：`2`
|
||||
>
|
||||
>解释：以下是最佳的方案之一，如图所示
|
||||
{:width="300px"}
|
||||
<p>给定该装饰的初始状态 <code>root</code>，请返回最少需要操作多少次开关，可以关闭所有节点的灯。</p>
|
||||
|
||||
**示例 2：**
|
||||
>输入：`root = [1,1,1,1,null,null,1]`
|
||||
>
|
||||
>输出：`1`
|
||||
>
|
||||
>解释：以下是最佳的方案，如图所示
|
||||
{:width="300px"}
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
**示例 3：**
|
||||
>输入：`root = [0,null,0]`
|
||||
>
|
||||
>输出：`0`
|
||||
>
|
||||
>解释：无需操作开关，当前所有节点上的灯均已关闭
|
||||
<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>
|
||||
|
||||
**提示：**
|
||||
- `1 <= 节点个数 <= 10^5`
|
||||
- `0 <= Node.val <= 1`
|
||||
<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,6 +1,6 @@
|
||||
<p>给定一个二叉树的<meta charset="UTF-8" /> <code>root</code> ，确定它是否是一个 <em>完全二叉树</em> 。</p>
|
||||
<p>给你一棵二叉树的根节点<meta charset="UTF-8" /> <code>root</code> ，请你判断这棵树是否是一棵 <strong>完全二叉树</strong> 。</p>
|
||||
|
||||
<p>在一个 <strong><a href="https://baike.baidu.com/item/完全二叉树/7773232?fr=aladdin" target="_blank">完全二叉树</a></strong> 中，除了最后一个关卡外，所有关卡都是完全被填满的，并且最后一个关卡中的所有节点都是尽可能靠左的。它可以包含<meta charset="UTF-8" /> <code>1</code> 到<meta charset="UTF-8" /> <code>2<sup>h</sup></code> 节点之间的最后一级 <code>h</code> 。</p>
|
||||
<p>在一棵 <strong><a href="https://baike.baidu.com/item/完全二叉树/7773232?fr=aladdin" target="_blank">完全二叉树</a></strong> 中，除了最后一层外，所有层都被完全填满，并且最后一层中的所有节点都尽可能靠左。最后一层（第 <code>h</code> 层）中可以包含<meta charset="UTF-8" /> <code>1</code> 到<meta charset="UTF-8" /> <code>2<sup>h</sup></code> 个节点。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,4,5,6]
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>最后一层前的每一层都是满的（即，结点值为 {1} 和 {2,3} 的两层），且最后一层中的所有结点（{4,5,6}）都尽可能地向左。
|
||||
<strong>解释：</strong>最后一层前的每一层都是满的（即，节点值为 {1} 和 {2,3} 的两层），且最后一层中的所有节点（{4,5,6}）尽可能靠左。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
@@ -21,7 +21,7 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,4,5,null,7]
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：</strong>值为 7 的结点没有尽可能靠向左侧。
|
||||
<strong>解释：</strong>值为 7 的节点不满足条件「节点尽可能靠左」。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
@@ -29,6 +29,6 @@
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树的结点数在范围 <meta charset="UTF-8" /> <code>[1, 100]</code> 内。</li>
|
||||
<li>树中节点数目在范围 <code>[1, 100]</code> 内</li>
|
||||
<li><code>1 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,16 +1,32 @@
|
||||
<p>给定一个二叉树，找出其最大深度。</p>
|
||||
<p>给定一个二叉树 <code>root</code> ，返回其最大深度。</p>
|
||||
|
||||
<p>二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。</p>
|
||||
<p>二叉树的 <strong>最大深度</strong> 是指从根节点到最远叶子节点的最长路径上的节点数。</p>
|
||||
|
||||
<p><strong>说明:</strong> 叶子节点是指没有子节点的节点。</p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例：</strong><br>
|
||||
给定二叉树 <code>[3,9,20,null,null,15,7]</code>，</p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre> 3
|
||||
/ \
|
||||
9 20
|
||||
/ \
|
||||
15 7</pre>
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg" style="width: 400px; height: 277px;" /></p>
|
||||
|
||||
<p>返回它的最大深度 3 。</p>
|
||||
<p> </p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>root = [3,9,20,null,null,15,7]
|
||||
<b>输出：</b>3
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>root = [1,null,2]
|
||||
<b>输出：</b>2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数量在 <code>[0, 10<sup>4</sup>]</code> 区间内。</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,19 +1,31 @@
|
||||
<p>给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。</p>
|
||||
<p>给你一棵二叉树的根节点，返回该树的 <strong>直径</strong> 。</p>
|
||||
|
||||
<p>二叉树的 <strong>直径</strong> 是指树中任意两个节点之间最长路径的 <strong>长度</strong> 。这条路径可能经过也可能不经过根节点 <code>root</code> 。</p>
|
||||
|
||||
<p>两节点之间路径的 <strong>长度</strong> 由它们之间边数表示。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 :</strong><br>
|
||||
给定二叉树</p>
|
||||
|
||||
<pre> 1
|
||||
/ \
|
||||
2 3
|
||||
/ \
|
||||
4 5
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/06/diamtree.jpg" style="width: 292px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,4,5]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
|
||||
</pre>
|
||||
|
||||
<p>返回 <strong>3</strong>, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。</p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2]
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>注意：</strong>两结点之间的路径长度是以它们之间边的数目表示。</p>
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[1, 10<sup>4</sup>]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,36 +1,35 @@
|
||||
<p>有两位极客玩家参与了一场「二叉树着色」的游戏。游戏中，给出二叉树的根节点 <code>root</code>，树上总共有 <code>n</code> 个节点，且 <code>n</code> 为奇数，其中每个节点上的值从 <code>1</code> 到 <code>n</code> 各不相同。</p>
|
||||
|
||||
<p> </p>
|
||||
<p>最开始时：</p>
|
||||
|
||||
<p>游戏从「一号」玩家开始（「一号」玩家为红色，「二号」玩家为蓝色），最开始时，</p>
|
||||
|
||||
<p>「一号」玩家从 <code>[1, n]</code> 中取一个值 <code>x</code>（<code>1 <= x <= n</code>）；</p>
|
||||
|
||||
<p>「二号」玩家也从 <code>[1, n]</code> 中取一个值 <code>y</code>（<code>1 <= y <= n</code>）且 <code>y != x</code>。</p>
|
||||
<ul>
|
||||
<li>「一号」玩家从 <code>[1, n]</code> 中取一个值 <code>x</code>（<code>1 <= x <= n</code>）；</li>
|
||||
<li>「二号」玩家也从 <code>[1, n]</code> 中取一个值 <code>y</code>（<code>1 <= y <= n</code>）且 <code>y != x</code>。</li>
|
||||
</ul>
|
||||
|
||||
<p>「一号」玩家给值为 <code>x</code> 的节点染上红色，而「二号」玩家给值为 <code>y</code> 的节点染上蓝色。</p>
|
||||
|
||||
<p> </p>
|
||||
<p>之后两位玩家轮流进行操作，「一号」玩家先手。每一回合，玩家选择一个被他染过色的节点，将所选节点一个 <strong>未着色 </strong>的邻节点（即左右子节点、或父节点）进行染色（「一号」玩家染红色，「二号」玩家染蓝色）。</p>
|
||||
|
||||
<p>之后两位玩家轮流进行操作，每一回合，玩家选择一个他之前涂好颜色的节点，将所选节点一个 <strong>未着色 </strong>的邻节点（即左右子节点、或父节点）进行染色。</p>
|
||||
|
||||
<p>如果当前玩家无法找到这样的节点来染色时，他的回合就会被跳过。</p>
|
||||
<p>如果（且仅在此种情况下）当前玩家无法找到这样的节点来染色时，其回合就会被跳过。</p>
|
||||
|
||||
<p>若两个玩家都没有可以染色的节点时，游戏结束。着色节点最多的那位玩家获得胜利 ✌️。</p>
|
||||
|
||||
<p> </p>
|
||||
<p>现在，假设你是「二号」玩家，根据所给出的输入，假如存在一个 <code>y</code> 值可以确保你赢得这场游戏，则返回 <code>true</code> ；若无法获胜，就请返回 <code>false</code> 。</p>
|
||||
|
||||
|
||||
<p>现在，假设你是「二号」玩家，根据所给出的输入，假如存在一个 <code>y</code> 值可以确保你赢得这场游戏，则返回 <code>true</code>；若无法获胜，就请返回 <code>false</code>。</p>
|
||||
<p><strong class="example">示例 1 ：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/08/01/1480-binary-tree-coloring-game.png" style="width: 500px; height: 310px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,4,5,6,7,8,9,10,11], n = 11, x = 3
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>第二个玩家可以选择值为 2 的节点。</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">示例 2 ：</strong></p>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/08/04/1480-binary-tree-coloring-game.png" style="height: 186px; width: 300px;"></strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>root = [1,2,3,4,5,6,7,8,9,10,11], n = 11, x = 3
|
||||
<strong>输出：</strong>True
|
||||
<strong>解释：</strong>第二个玩家可以选择值为 2 的节点。
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3], n = 3, x = 1
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
@@ -38,7 +37,9 @@
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>二叉树的根节点为 <code>root</code>，树上由 <code>n</code> 个节点，节点上的值从 <code>1</code> 到 <code>n</code> 各不相同。</li>
|
||||
<li><code>n</code> 为奇数。</li>
|
||||
<li><code>1 <= x <= n <= 100</code></li>
|
||||
<li>树中节点数目为 <code>n</code></li>
|
||||
<li><code>1 <= x <= n <= 100</code></li>
|
||||
<li><code>n</code> 是奇数</li>
|
||||
<li><code>1 <= Node.val <= n</code></li>
|
||||
<li>树中所有值 <strong>互不相同</strong></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
<p>二进制手表顶部有 4 个 LED 代表<strong> 小时（0-11）</strong>，底部的 6 个 LED 代表<strong> 分钟（0-59）</strong>。每个 LED 代表一个 0 或 1，最低位在右侧。</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，下面的二进制手表读取 <code>"3:25"</code> 。</li>
|
||||
<li>例如，下面的二进制手表读取 <code>"4:51"</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p><img src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/03/29/binary_clock_samui_moon.jpg" style="height: 300px; width" /></p>
|
||||
|
||||
<p><small><em>（图源：<a href="https://commons.m.wikimedia.org/wiki/File:Binary_clock_samui_moon.jpg">WikiMedia - Binary clock samui moon.jpg</a> ，许可协议：<a href="https://creativecommons.org/licenses/by-sa/3.0/deed.en">Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)</a> ）</em></small></p>
|
||||
<p><img src="https://assets.leetcode.com/uploads/2021/04/08/binarywatch.jpg" style="height: 300px; width" /></p>
|
||||
|
||||
<p>给你一个整数 <code>turnedOn</code> ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以 <strong>按任意顺序</strong> 返回答案。</p>
|
||||
|
||||
@@ -22,7 +20,7 @@
|
||||
<li>例如，<code>"10:2"</code> 是无效的时间，正确的写法应该是 <code>"10:02"</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -38,10 +36,10 @@
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= turnedOn <= 10</code></li>
|
||||
<li><code>0 <= turnedOn <= 10</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,25 +1,25 @@
|
||||
<p>给你两个二进制字符串，返回它们的和（用二进制表示）。</p>
|
||||
|
||||
<p>输入为 <strong>非空 </strong>字符串且只包含数字 <code>1</code> 和 <code>0</code>。</p>
|
||||
<p>给你两个二进制字符串 <code>a</code> 和 <code>b</code> ，以二进制字符串的形式返回它们的和。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> a = "11", b = "1"
|
||||
<strong>输出:</strong> "100"</pre>
|
||||
<pre>
|
||||
<strong>输入:</strong>a = "11", b = "1"
|
||||
<strong>输出：</strong>"100"</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> a = "1010", b = "1011"
|
||||
<strong>输出:</strong> "10101"</pre>
|
||||
<pre>
|
||||
<strong>输入：</strong>a = "1010", b = "1011"
|
||||
<strong>输出：</strong>"10101"</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>每个字符串仅由字符 <code>'0'</code> 或 <code>'1'</code> 组成。</li>
|
||||
<li><code>1 <= a.length, b.length <= 10^4</code></li>
|
||||
<li>字符串如果不是 <code>"0"</code> ，就都不含前导零。</li>
|
||||
<li><code>1 <= a.length, b.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>a</code> 和 <code>b</code> 仅由字符 <code>'0'</code> 或 <code>'1'</code> 组成</li>
|
||||
<li>字符串如果不是 <code>"0"</code> ，就不含前导零</li>
|
||||
</ul>
|
||||
|
||||
@@ -3,13 +3,13 @@
|
||||
<p>二进制矩阵中的 畅通路径 是一条从 <strong>左上角</strong> 单元格（即，<code>(0, 0)</code>）到 右下角 单元格（即，<code>(n - 1, n - 1)</code>）的路径，该路径同时满足下述要求：</p>
|
||||
|
||||
<ul>
|
||||
<li>路径途经的所有单元格都的值都是 <code>0</code> 。</li>
|
||||
<li>路径途经的所有单元格的值都是 <code>0</code> 。</li>
|
||||
<li>路径中所有相邻的单元格应当在 <strong>8 个方向之一</strong> 上连通（即，相邻两单元之间彼此不同且共享一条边或者一个角）。</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>畅通路径的长度</strong> 是该路径途经的单元格总数。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/example1_1.png" style="width: 500px; height: 234px;" />
|
||||
@@ -32,13 +32,13 @@
|
||||
<strong>输出：</strong>-1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code>grid[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
<p>给你一个正整数的数组 <code>A</code>（其中的元素不一定完全不同），请你返回可在 <strong>一次交换</strong>（交换两数字 <code>A[i]</code> 和 <code>A[j]</code> 的位置）后得到的、按字典序排列小于 <code>A</code> 的最大可能排列。</p>
|
||||
<p>给你一个正整数数组 <code>arr</code>（可能存在重复的元素），请你返回可在 <strong>一次交换</strong>（交换两数字 <code>arr[i]</code> 和 <code>arr[j]</code> 的位置）后得到的、按字典序排列小于 <code>arr</code> 的最大排列。</p>
|
||||
|
||||
<p>如果无法这么操作，就请返回原数组。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -28,19 +28,11 @@
|
||||
<strong>解释：</strong>交换 9 和 7
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>arr = [3,1,1,3]
|
||||
<strong>输出：</strong>[1,3,1,3]
|
||||
<strong>解释：</strong>交换 1 和 3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= arr.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= arr[i] <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= arr.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= arr[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>有两个长度相同的字符串 <code>s1</code> 和 <code>s2</code>，且它们其中 <strong>只含有</strong> 字符 <code>"x"</code> 和 <code>"y"</code>，你需要通过「交换字符」的方式使这两个字符串相同。</p>
|
||||
<p>有两个长度相同的字符串 <code>s1</code> 和 <code>s2</code>，且它们其中 <strong>只含有</strong> 字符 <code>"x"</code> 和 <code>"y"</code>，你需要通过「交换字符」的方式使这两个字符串相同。</p>
|
||||
|
||||
<p>每次「交换字符」的时候，你都可以在两个字符串中各选一个字符进行交换。</p>
|
||||
|
||||
@@ -8,39 +8,37 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "xx", s2 = "yy"
|
||||
<pre>
|
||||
<strong>输入：</strong>s1 = "xx", s2 = "yy"
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：
|
||||
</strong>交换 s1[0] 和 s2[1]，得到 s1 = "yx"，s2 = "yx"。</pre>
|
||||
</strong>交换 s1[0] 和 s2[1]，得到 s1 = "yx"，s2 = "yx"。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "xy", s2 = "yx"
|
||||
<pre>
|
||||
<strong>输入：</strong>s1 = "xy", s2 = "yx"
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：
|
||||
</strong>交换 s1[0] 和 s2[0]，得到 s1 = "yy"，s2 = "xx" 。
|
||||
交换 s1[0] 和 s2[1]，得到 s1 = "xy"，s2 = "xy" 。
|
||||
注意，你不能交换 s1[0] 和 s1[1] 使得 s1 变成 "yx"，因为我们只能交换属于两个不同字符串的字符。</pre>
|
||||
</strong>交换 s1[0] 和 s2[0]，得到 s1 = "yy"，s2 = "xx" 。
|
||||
交换 s1[0] 和 s2[1]，得到 s1 = "xy"，s2 = "xy" 。
|
||||
注意，你不能交换 s1[0] 和 s1[1] 使得 s1 变成 "yx"，因为我们只能交换属于两个不同字符串的字符。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "xx", s2 = "xy"
|
||||
<pre>
|
||||
<strong>输入：</strong>s1 = "xx", s2 = "xy"
|
||||
<strong>输出：</strong>-1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>s1 = "xxyyxyxyxx", s2 = "xyyxyxxxyx"
|
||||
<strong>输出：</strong>4
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s1.length, s2.length <= 1000</code></li>
|
||||
<li><code>s1, s2</code> 只包含 <code>'x'</code> 或 <code>'y'</code>。</li>
|
||||
<li><code>s1.length == s2.length</code></li>
|
||||
<li><code>s1, s2</code> 只包含 <code>'x'</code> 或 <code>'y'</code>。</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,33 +1,62 @@
|
||||
<p>某网站包含两个表，<code>Customers</code> 表和 <code>Orders</code> 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。</p>
|
||||
|
||||
<p><code>Customers</code> 表：</p>
|
||||
|
||||
<pre>+----+-------+
|
||||
| Id | Name |
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| id | int |
|
||||
| name | varchar |
|
||||
+-------------+---------+
|
||||
在 SQL 中，id 是该表的主键。
|
||||
该表的每一行都表示客户的 ID 和名称。</pre>
|
||||
|
||||
<p><code>Orders</code> 表：</p>
|
||||
|
||||
<pre>
|
||||
+-------------+------+
|
||||
| Column Name | Type |
|
||||
+-------------+------+
|
||||
| id | int |
|
||||
| customerId | int |
|
||||
+-------------+------+
|
||||
在 SQL 中，id 是该表的主键。
|
||||
customerId 是 Customers 表中 ID 的外键( Pandas 中的连接键)。
|
||||
该表的每一行都表示订单的 ID 和订购该订单的客户的 ID。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>找出所有从不点任何东西的顾客。</p>
|
||||
|
||||
<p>以 <strong>任意顺序</strong> 返回结果表。</p>
|
||||
|
||||
<p>结果格式如下所示。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>
|
||||
Customers table:
|
||||
+----+-------+
|
||||
| id | name |
|
||||
+----+-------+
|
||||
| 1 | Joe |
|
||||
| 2 | Henry |
|
||||
| 3 | Sam |
|
||||
| 4 | Max |
|
||||
+----+-------+
|
||||
</pre>
|
||||
|
||||
<p><code>Orders</code> 表：</p>
|
||||
|
||||
<pre>+----+------------+
|
||||
| Id | CustomerId |
|
||||
Orders table:
|
||||
+----+------------+
|
||||
| id | customerId |
|
||||
+----+------------+
|
||||
| 1 | 3 |
|
||||
| 2 | 1 |
|
||||
+----+------------+
|
||||
</pre>
|
||||
|
||||
<p>例如给定上述表格，你的查询应返回：</p>
|
||||
|
||||
<pre>+-----------+
|
||||
<b>输出：</b>
|
||||
+-----------+
|
||||
| Customers |
|
||||
+-----------+
|
||||
| Henry |
|
||||
| Max |
|
||||
+-----------+
|
||||
</pre>
|
||||
+-----------+</pre>
|
||||
|
||||
@@ -1,30 +1,31 @@
|
||||
<p>你有一辆货运卡车，你需要用这一辆车把一些箱子从仓库运送到码头。这辆卡车每次运输有 <strong>箱子数目的限制</strong> 和 <strong>总重量的限制</strong> 。</p>
|
||||
<p>你有一辆货运卡车，你需要用这一辆车把一些箱子从仓库运送到码头。这辆卡车每次运输有 <strong>箱子数目的限制</strong> 和 <strong>总重量的限制</strong> 。</p>
|
||||
|
||||
<p>给你一个箱子数组 <code>boxes</code> 和三个整数 <code>portsCount</code>, <code>maxBoxes</code> 和 <code>maxWeight</code> ，其中 <code>boxes[i] = [ports<sub>i</sub>, weight<sub>i</sub>]</code> 。</p>
|
||||
<p>给你一个箱子数组 <code>boxes</code> 和三个整数 <code>portsCount</code>, <code>maxBoxes</code> 和 <code>maxWeight</code> ，其中 <code>boxes[i] = [ports<sub>i</sub>, weight<sub>i</sub>]</code> 。</p>
|
||||
|
||||
<ul>
|
||||
<li><code>ports<sub>i</sub></code> 表示第 <code>i</code> 个箱子需要送达的码头， <code>weights<sub>i</sub></code> 是第 <code>i</code> 个箱子的重量。</li>
|
||||
<li><code>portsCount</code> 是码头的数目。</li>
|
||||
<li><code>maxBoxes</code> 和 <code>maxWeight</code> 分别是卡车每趟运输箱子数目和重量的限制。</li>
|
||||
<li><code>ports<sub>i</sub></code> 表示第 <code>i</code> 个箱子需要送达的码头， <code>weights<sub>i</sub></code> 是第 <code>i</code> 个箱子的重量。</li>
|
||||
<li><code>portsCount</code> 是码头的数目。</li>
|
||||
<li><code>maxBoxes</code> 和 <code>maxWeight</code> 分别是卡车每趟运输箱子数目和重量的限制。</li>
|
||||
</ul>
|
||||
|
||||
<p>箱子需要按照 <strong>数组顺序</strong> 运输，同时每次运输需要遵循以下步骤：</p>
|
||||
<p>箱子需要按照 <strong>数组顺序</strong> 运输，同时每次运输需要遵循以下步骤：</p>
|
||||
|
||||
<ul>
|
||||
<li>卡车从 <code>boxes</code> 队列中按顺序取出若干个箱子，但不能违反 <code>maxBoxes</code> 和 <code>maxWeight</code> 限制。</li>
|
||||
<li>对于在卡车上的箱子，我们需要 <strong>按顺序</strong> 处理它们，卡车会通过 <strong>一趟行程</strong> 将最前面的箱子送到目的地码头并卸货。如果卡车已经在对应的码头，那么不需要 <strong>额外行程</strong> ，箱子也会立马被卸货。</li>
|
||||
<li>卡车上所有箱子都被卸货后，卡车需要 <strong>一趟行程</strong> 回到仓库，从箱子队列里再取出一些箱子。</li>
|
||||
<li>卡车从 <code>boxes</code> 队列中按顺序取出若干个箱子，但不能违反 <code>maxBoxes</code> 和 <code>maxWeight</code> 限制。</li>
|
||||
<li>对于在卡车上的箱子，我们需要 <strong>按顺序</strong> 处理它们，卡车会通过 <strong>一趟行程</strong> 将最前面的箱子送到目的地码头并卸货。如果卡车已经在对应的码头，那么不需要 <strong>额外行程</strong> ，箱子也会立马被卸货。</li>
|
||||
<li>卡车上所有箱子都被卸货后，卡车需要 <strong>一趟行程</strong> 回到仓库，从箱子队列里再取出一些箱子。</li>
|
||||
</ul>
|
||||
|
||||
<p>卡车在将所有箱子运输并卸货后，最后必须回到仓库。</p>
|
||||
|
||||
<p>请你返回将所有箱子送到相应码头的 <b>最少行程</b> 次数。</p>
|
||||
<p>请你返回将所有箱子送到相应码头的 <b>最少行程</b> 次数。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>boxes = [[1,1],[2,1],[1,1]], portsCount = 2, maxBoxes = 3, maxWeight = 3
|
||||
<pre>
|
||||
<strong>输入：</strong>boxes = [[1,1],[2,1],[1,1]], portsCount = 2, maxBoxes = 3, maxWeight = 3
|
||||
<b>输出：</b>4
|
||||
<b>解释：</b>最优策略如下：
|
||||
- 卡车将所有箱子装上车，到达码头 1 ，然后去码头 2 ，然后再回到码头 1 ，最后回到仓库，总共需要 4 趟行程。
|
||||
@@ -34,18 +35,20 @@
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>boxes = [[1,2],[3,3],[3,1],[3,1],[2,4]], portsCount = 3, maxBoxes = 3, maxWeight = 6
|
||||
<pre>
|
||||
<b>输入：</b>boxes = [[1,2],[3,3],[3,1],[3,1],[2,4]], portsCount = 3, maxBoxes = 3, maxWeight = 6
|
||||
<b>输出：</b>6
|
||||
<b>解释：</b>最优策略如下：
|
||||
- 卡车首先运输第一个箱子，到达码头 1 ，然后回到仓库，总共 2 趟行程。
|
||||
- 卡车运输第二、第三、第四个箱子，到达码头 3 ，然后回到仓库，总共 2 趟行程。
|
||||
- 卡车运输第五个箱子，到达码头 3 ，回到仓库，总共 2 趟行程。
|
||||
- 卡车运输第五个箱子，到达码头 2 ，回到仓库，总共 2 趟行程。
|
||||
总行程数为 2 + 2 + 2 = 6 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>boxes = [[1,4],[1,2],[2,1],[2,1],[3,2],[3,4]], portsCount = 3, maxBoxes = 6, maxWeight = 7
|
||||
<pre>
|
||||
<b>输入：</b>boxes = [[1,4],[1,2],[2,1],[2,1],[3,2],[3,4]], portsCount = 3, maxBoxes = 6, maxWeight = 7
|
||||
<b>输出：</b>6
|
||||
<b>解释：</b>最优策略如下：
|
||||
- 卡车运输第一和第二个箱子，到达码头 1 ，然后回到仓库，总共 2 趟行程。
|
||||
@@ -56,7 +59,8 @@
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>boxes = [[2,4],[2,5],[3,1],[3,2],[3,7],[3,1],[4,4],[1,3],[5,2]], portsCount = 5, maxBoxes = 5, maxWeight = 7
|
||||
<pre>
|
||||
<b>输入：</b>boxes = [[2,4],[2,5],[3,1],[3,2],[3,7],[3,1],[4,4],[1,3],[5,2]], portsCount = 5, maxBoxes = 5, maxWeight = 7
|
||||
<b>输出：</b>14
|
||||
<b>解释：</b>最优策略如下：
|
||||
- 卡车运输第一个箱子，到达码头 2 ，然后回到仓库，总共 2 趟行程。
|
||||
@@ -68,7 +72,7 @@
|
||||
总行程数为 2 + 2 + 2 + 2 + 3 + 3 = 14 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<p>给你一个链表的头节点 <code>head</code> 。</p>
|
||||
|
||||
<p>对于列表中的每个节点 <code>node</code> ，如果其右侧存在一个具有 <strong>严格更大</strong> 值的节点，则移除 <code>node</code> 。</p>
|
||||
<p>移除每个右侧有一个更大数值的节点。</p>
|
||||
|
||||
<p>返回修改后链表的头节点<em> </em><code>head</code><em> </em>。</p>
|
||||
|
||||
|
||||
@@ -1,17 +1,17 @@
|
||||
<p>你的初始 <strong>能量</strong> 为 <code>P</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>
|
||||
|
||||
<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>如果你至少有 <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>
|
||||
</ul>
|
||||
|
||||
<p>每个令牌 <strong>最多</strong> 只能使用一次，使用 <strong>顺序不限</strong> ，<strong>不需</strong> 使用所有令牌。</p>
|
||||
|
||||
<p>在使用任意数量的令牌后，返回我们可以得到的最大 <strong>分数</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<ol>
|
||||
</ol>
|
||||
@@ -19,21 +19,22 @@
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = [100], P = 50
|
||||
<strong>输入：</strong>tokens = [100], power = 50
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>无法使用唯一的令牌，因为能量和分数都太少了。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = [100,200], P = 150
|
||||
<strong>输入：</strong>tokens = [100,200], power = 150
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>令牌 0 正面朝上，能量变为 50，分数变为 1 。不必使用令牌 1 ，因为你无法使用它来提高分数。</pre>
|
||||
<strong>解释：</strong>令牌 0 正面朝上，能量变为 50，分数变为 1 。
|
||||
不必使用令牌 1 ，因为你无法使用它来提高分数。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = [100,200,300,400], P = 200
|
||||
<strong>输入：</strong>tokens = [100,200,300,400], power = 200
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>按下面顺序使用令牌可以得到 2 分：
|
||||
1. 令牌 0 正面朝上，能量变为 100 ，分数变为 1
|
||||
@@ -41,11 +42,11 @@
|
||||
3. 令牌 1 正面朝上，能量变为 300 ，分数变为 1
|
||||
4. 令牌 2 正面朝上，能量变为 0 ，分数变为 2</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= tokens.length <= 1000</code></li>
|
||||
<li><code>0 <= tokens[i], P < 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= tokens.length <= 1000</code></li>
|
||||
<li><code>0 <= tokens[i], power < 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
<p><strong>句子</strong> 是由若干个单词组成的字符串，单词之间用单个空格分隔，其中每个单词可以包含数字、小写字母、和美元符号 <code>'$'</code> 。如果单词的形式为美元符号后跟着一个非负实数，那么这个单词就表示一个价格。</p>
|
||||
<p><strong>句子</strong> 是由若干个单词组成的字符串，单词之间用单个空格分隔，其中每个单词可以包含数字、小写字母、和美元符号 <code>'$'</code> 。如果单词的形式为美元符号后跟着一个非负实数，那么这个单词就表示一个 <strong>价格</strong> 。</p>
|
||||
|
||||
<ul>
|
||||
<li>例如 <code>"$100"</code>、<code>"$23"</code> 和 <code>"$6.75"</code> 表示价格，而 <code>"100"</code>、<code>"$"</code> 和 <code>"2$3"</code> 不是。</li>
|
||||
<li>例如 <code>"$100"</code>、<code>"$23"</code> 和 <code>"$6"</code> 表示价格，而 <code>"100"</code>、<code>"$"</code> 和 <code>"$1e5</code> 不是。</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>注意：</strong>本题输入中的价格均为整数。</p>
|
||||
|
||||
<p>给你一个字符串 <code>sentence</code> 和一个整数 <code>discount</code> 。对于每个表示价格的单词，都在价格的基础上减免 <code>discount%</code> ，并 <strong>更新</strong> 该单词到句子中。所有更新后的价格应该表示为一个 <strong>恰好保留小数点后两位</strong> 的数字。</p>
|
||||
<p>给你一个字符串 <code>sentence</code> 表示一个句子和一个整数 <code>discount</code> 。对于每个表示价格的单词，都在价格的基础上减免 <code>discount%</code> ，并 <strong>更新</strong> 该单词到句子中。所有更新后的价格应该表示为一个 <strong>恰好保留小数点后两位</strong> 的数字。</p>
|
||||
|
||||
<p>返回表示修改后句子的字符串。</p>
|
||||
|
||||
<p>注意：所有价格 <strong>最多</strong> 为 <code>10</code> 位数字。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
<p>给定两个大小相等的数组 <code>nums1</code> 和 <code>nums2</code>，<code>nums1</code> 相对于 <code>nums</code> 的<em>优势</em>可以用满足 <code>nums1[i] > nums2[i]</code> 的索引 <code>i</code> 的数目来描述。</p>
|
||||
<p>给定两个长度相等的数组 <code>nums1</code> 和 <code>nums2</code>，<code>nums1</code> 相对于 <code>nums2</code> 的<em>优势</em>可以用满足 <code>nums1[i] > nums2[i]</code> 的索引 <code>i</code> 的数目来描述。</p>
|
||||
|
||||
<p>返回 <font color="#c7254e" face="Menlo, Monaco, Consolas, Courier New, monospace" size="1"><span style="background-color: rgb(249, 242, 244);">nums1</span></font> 的<strong>任意</strong>排列，使其相对于 <code>nums2</code> 的优势最大化。</p>
|
||||
|
||||
|
||||
@@ -1,22 +1,22 @@
|
||||
<p>编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为 <a href="http://en.wikipedia.org/wiki/Hamming_weight" target="_blank">汉明重量</a>).）。</p>
|
||||
<p>编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为 <a href="http://en.wikipedia.org/wiki/Hamming_weight" target="_blank">汉明重量</a>).）。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。</li>
|
||||
<li>在 Java 中，编译器使用 <a href="https://baike.baidu.com/item/二进制补码/5295284">二进制补码</a> 记法来表示有符号整数。因此，在上面的 <strong>示例 3 </strong>中，输入表示有符号整数 <code>-3</code>。</li>
|
||||
<li>在 Java 中，编译器使用 <a href="https://baike.baidu.com/item/二进制补码/5295284">二进制补码</a> 记法来表示有符号整数。因此，在上面的 <strong>示例 3 </strong>中，输入表示有符号整数 <code>-3</code>。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 11 (控制台输入 00000000000000000000000000001011)
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong> 中，共有三位为 '1'。</code>
|
||||
<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong> 中，共有三位为 '1'。</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
@@ -24,7 +24,7 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 128 (控制台输入 00000000000000000000000010000000)
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong> 中，共有一位为 '1'。
|
||||
<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong> 中，共有一位为 '1'。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
@@ -34,7 +34,7 @@
|
||||
<strong>输出：</strong>31
|
||||
<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 中，共有 31 位为 '1'。</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
@@ -42,6 +42,8 @@
|
||||
<li>输入必须是长度为 <code>32</code> 的 <strong>二进制串</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p>注意：本题与主站 191 题相同：<a href="https://leetcode-cn.com/problems/number-of-1-bits/">https://leetcode-cn.com/problems/number-of-1-bits/</a></p>
|
||||
|
||||
<p> </p>
|
||||
@@ -1,40 +1,40 @@
|
||||
<p>编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为<a href="https://baike.baidu.com/item/%E6%B1%89%E6%98%8E%E9%87%8D%E9%87%8F" target="_blank">汉明重量</a>）。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。</li>
|
||||
<li>在 Java 中，编译器使用<a href="https://baike.baidu.com/item/二进制补码/5295284" target="_blank">二进制补码</a>记法来表示有符号整数。因此，在上面的 <strong>示例 3</strong> 中，输入表示有符号整数 <code>-3</code>。</li>
|
||||
<li>在 Java 中，编译器使用<a href="https://baike.baidu.com/item/二进制补码/5295284" target="_blank">二进制补码</a>记法来表示有符号整数。因此，在 <strong>示例 3</strong> 中，输入表示有符号整数 <code>-3</code>。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>00000000000000000000000000001011
|
||||
<strong>输入：</strong>n = 00000000000000000000000000001011
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong> 中，共有三位为 '1'。</code>
|
||||
<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong> 中，共有三位为 '1'。</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>00000000000000000000000010000000
|
||||
<strong>输入：</strong>n = 00000000000000000000000010000000
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong> 中，共有一位为 '1'。
|
||||
<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong> 中，共有一位为 '1'。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>11111111111111111111111111111101
|
||||
<strong>输入：</strong>n = 11111111111111111111111111111101
|
||||
<strong>输出：</strong>31
|
||||
<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 中，共有 31 位为 '1'。</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
@@ -45,7 +45,7 @@
|
||||
<ul>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶</strong>：</p>
|
||||
|
||||
|
||||
@@ -7,14 +7,14 @@
|
||||
| visit_date | date |
|
||||
| people | int |
|
||||
+---------------+---------+
|
||||
visit_date 是表的主键
|
||||
visit_date 是该表中具有唯一值的列。
|
||||
每日人流量信息被记录在这三列信息中：<strong>序号</strong> (id)、<strong>日期</strong> (visit_date)、 <strong>人流量</strong> (people)
|
||||
每天只有一行记录，日期随着 id 的增加而增加
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>编写一个 SQL 查询以找出每行的人数大于或等于 <code>100</code> 且 <code>id</code> 连续的三行或更多行记录。</p>
|
||||
<p>编写解决方案找出每行的人数大于或等于 <code>100</code> 且 <code>id</code> 连续的三行或更多行记录。</p>
|
||||
|
||||
<p>返回按 <code>visit_date</code> <strong>升序排列</strong> 的结果表。</p>
|
||||
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
<p>给你一个字符串 <code>s</code> ，它仅包含字符 <code>'a'</code> 和 <code>'b'</code> 。</p>
|
||||
<p>给你一个字符串 <code>s</code> ，它仅包含字符 <code>'a'</code> 和 <code>'b'</code> 。</p>
|
||||
|
||||
<p>你可以删除 <code>s</code> 中任意数目的字符，使得 <code>s</code> <strong>平衡</strong> 。我们称 <code>s</code> <strong>平衡的</strong> 当不存在下标对 <code>(i,j)</code> 满足 <code>i < j</code> 且 <code>s[i] = 'b'</code> 同时 <code>s[j]= 'a'</code> 。</p>
|
||||
<p>你可以删除 <code>s</code> 中任意数目的字符，使得 <code>s</code> <strong>平衡</strong> 。当不存在下标对 <code>(i,j)</code> 满足 <code>i < j</code> ，且 <code>s[i] = 'b'</code> 的同时 <code>s[j]= 'a'</code> ，此时认为 <code>s</code> 是 <strong>平衡 </strong>的。</p>
|
||||
|
||||
<p>请你返回使 <code>s</code> <strong>平衡</strong> 的 <strong>最少</strong> 删除次数。</p>
|
||||
<p>请你返回使 <code>s</code> <strong>平衡</strong> 的 <strong>最少</strong> 删除次数。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
@@ -12,8 +12,8 @@
|
||||
<b>输入：</b>s = "aababbab"
|
||||
<b>输出：</b>2
|
||||
<b>解释：</b>你可以选择以下任意一种方案：
|
||||
下标从 0 开始，删除第 2 和第 6 个字符（"aa<strong>b</strong>abb<strong>a</strong>b" -> "aaabbb"），
|
||||
下标从 0 开始，删除第 3 和第 6 个字符（"aab<strong>a</strong>bb<strong>a</strong>b" -> "aabbbb"）。
|
||||
下标从 0 开始，删除第 2 和第 6 个字符（"aa<strong>b</strong>abb<strong>a</strong>b" -> "aaabbb"），
|
||||
下标从 0 开始，删除第 3 和第 6 个字符（"aab<strong>a</strong>bb<strong>a</strong>b" -> "aabbbb"）。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
@@ -24,11 +24,11 @@
|
||||
<b>解释：</b>唯一的最优解是删除最前面两个字符。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s[i]</code> 要么是 <code>'a'</code> 要么是 <code>'b'</code><strong> </strong>。</li>
|
||||
<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s[i]</code> 要么是 <code>'a'</code> 要么是 <code>'b'</code><strong> </strong>。</li>
|
||||
</ul>
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
<li>它可以被写作 <code>(A)</code>，其中 <code>A</code> 是有效字符串。</li>
|
||||
</ul>
|
||||
|
||||
<p>给定一个括号字符串 <code>s</code> ，移动N次，你就可以在字符串的任何位置插入一个括号。</p>
|
||||
<p>给定一个括号字符串 <code>s</code> ，在每一次操作中，你都可以在字符串的任何位置插入一个括号</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，如果 <code>s = "()))"</code> ，你可以插入一个开始括号为 <code>"(()))"</code> 或结束括号为 <code>"())))"</code> 。</li>
|
||||
|
||||
@@ -6,23 +6,26 @@
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]
|
||||
<pre>
|
||||
<strong>输入：</strong>arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>用 2 来替换 <code>5，之后</code> <code>arr1 = [1, 2, 3, 6, 7]</code>。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>arr1 = [1,5,3,6,7], arr2 = [4,3,1]
|
||||
<pre>
|
||||
<strong>输入：</strong>arr1 = [1,5,3,6,7], arr2 = [4,3,1]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>用 3 来替换 <code>5，然后</code>用 4 来替换 3<code>，得到</code> <code>arr1 = [1, 3, 4, 6, 7]</code>。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>arr1 = [1,5,3,6,7], arr2 = [1,6,3,3]
|
||||
<pre>
|
||||
<strong>输入：</strong>arr1 = [1,5,3,6,7], arr2 = [1,6,3,3]
|
||||
<strong>输出：</strong>-1
|
||||
<strong>解释：</strong>无法使 <code>arr1 严格递增</code>。</pre>
|
||||
|
||||
|
||||
@@ -14,7 +14,8 @@
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [1,3,5,2], cost = [2,3,1,14]
|
||||
<pre>
|
||||
<b>输入：</b>nums = [1,3,5,2], cost = [2,3,1,14]
|
||||
<b>输出：</b>8
|
||||
<b>解释：</b>我们可以执行以下操作使所有元素变为 2 ：
|
||||
- 增加第 0 个元素 1 次，开销为 2 。
|
||||
@@ -26,7 +27,8 @@
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><b>输入：</b>nums = [2,2,2,2,2], cost = [4,2,8,1,3]
|
||||
<pre>
|
||||
<b>输入：</b>nums = [2,2,2,2,2], cost = [4,2,8,1,3]
|
||||
<b>输出：</b>0
|
||||
<b>解释：</b>数组中所有元素已经全部相等，不需要执行额外的操作。
|
||||
</pre>
|
||||
@@ -39,4 +41,5 @@
|
||||
<li><code>n == nums.length == cost.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i], cost[i] <= 10<sup>6</sup></code></li>
|
||||
<li>测试用例确保输出不超过 2<sup>53</sup>-1。</li>
|
||||
</ul>
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
<li><code>subtract</code> - 从 <code>result</code> 中减去给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。</li>
|
||||
<li><code>multiply</code> - 将 <code>result</code> 乘以给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。</li>
|
||||
<li><code>divide</code> - 将 <code>result</code> 除以给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。如果传入的值为 <code>0</code> ，则抛出错误 <code>"Division by zero is not allowed"</code> 。</li>
|
||||
<li><code>power</code> - 将 <code>result</code> 的值乘以给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。</li>
|
||||
<li><code>power</code> - 计算 <code>result</code> 的幂，指数为给定的数字 <code>value</code> ，并返回更新后的 <code>Calculator</code> 对象。（<code>result = result ^ value</code> ）</li>
|
||||
<li><code>getResult</code> - 返回 <code>result</code> 的值。</li>
|
||||
</ul>
|
||||
|
||||
@@ -18,7 +18,8 @@
|
||||
<p><b>示例 1：</b></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["Calculator", "add", "subtract", "getResult"], values = [10, 5, 7]
|
||||
<b>输入：</b>actions = ["Calculator", "add", "subtract", "getResult"],
|
||||
values = [10, 5, 7]
|
||||
<b>输出：</b>8
|
||||
<b>解释：</b>
|
||||
new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8
|
||||
@@ -27,7 +28,8 @@ new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["Calculator", "multiply", "power", "getResult"], values = [2, 5, 2]
|
||||
<b>输入：</b>actions = ["Calculator", "multiply", "power", "getResult"],
|
||||
values = [2, 5, 2]
|
||||
<b>输出：</b>100
|
||||
<b>解释：</b>
|
||||
new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100
|
||||
@@ -36,7 +38,8 @@ new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100
|
||||
<p><strong class="example">示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>actions = ["Calculator", "divide", "getResult"], values = [20, 0]
|
||||
<b>输入：</b>actions = ["Calculator", "divide", "getResult"],
|
||||
values = [20, 0]
|
||||
<b>输出：</b>"Division by zero is not allowed"
|
||||
<b>解释：</b>
|
||||
new Calculator(20).divide(0).getResult() // 20 / 0
|
||||
@@ -49,9 +52,11 @@ new Calculator(20).divide(0).getResult() // 20 / 0
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>actions</code> 是一个有效的 JSON 字符串数组</li>
|
||||
<li><code>values</code> 是一个有效的 JSON 字符串数组</li>
|
||||
<li><code>2 <= actions.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= values.length <= 2 * 10<sup>4</sup></code><code> - 1</code></li>
|
||||
<li><code>actions[i] 是 "Calculator", "add", "subtract", "multiply", "divide", "power", 和 "getResult" 其中的元素</code></li>
|
||||
<li><code><font face="monospace">最后一个操作总是 "getResult"</font></code></li>
|
||||
<li><code><font face="monospace">values </font>是一个数字的 JSON 数组</code></li>
|
||||
<li><code>1 <= values.length <= 2 * 10<sup>4</sup> - 1</code></li>
|
||||
<li><code>actions[i]</code> 是 "Calculator", "add", "subtract", "multiply", "divide", "power", 和 "getResult" 其中的元素</li>
|
||||
<li>第一个操作总是 "Calculator"</li>
|
||||
<li>最后一个操作总是 "getResult"</li>
|
||||
</ul>
|
||||
|
||||
@@ -1,59 +1,36 @@
|
||||
<p>给你一个由若干 <code>0</code> 和 <code>1</code> 组成的二维网格 <code>grid</code> ，其中 <code>0</code> 表示水，而 <code>1</code> 表示陆地。岛屿由水平方向或竖直方向上相邻的 <code>1</code> （陆地）连接形成。</p>
|
||||
<p>给你一个大小为 <code>m x n</code> ，由若干 <code>0</code> 和 <code>1</code> 组成的二维网格 <code>grid</code> ，其中 <code>1</code> 表示陆地， <code>0</code> 表示水。<strong>岛屿</strong> 由水平方向或竖直方向上相邻的 <code>1</code> （陆地）连接形成。</p>
|
||||
|
||||
<p>如果 <strong>恰好只有一座岛屿 </strong>，则认为陆地是 <strong>连通的</strong> ；否则，陆地就是 <strong>分离的</strong> 。</p>
|
||||
|
||||
<p>一天内，可以将任何单个陆地单元（<code>1</code>）更改为水单元（<code>0</code>）。</p>
|
||||
<p>一天内，可以将 <strong>任何单个</strong> 陆地单元（<code>1</code>）更改为水单元（<code>0</code>）。</p>
|
||||
|
||||
<p>返回使陆地分离的最少天数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/08/30/1926_island.png" style="height: 139px; width: 498px;"></strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>grid = [[0,1,1,0],[0,1,1,0],[0,0,0,0]]
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/24/land1.jpg" style="width: 500px; height: 169px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[0,1,1,0],[0,1,1,0],[0,0,0,0]]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>至少需要 2 天才能得到分离的陆地。
|
||||
将陆地 grid[1][1] 和 grid[0][2] 更改为水，得到两个分离的岛屿。
|
||||
</pre>
|
||||
将陆地 grid[1][1] 和 grid[0][2] 更改为水，得到两个分离的岛屿。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>grid = [[1,1]]
|
||||
<p><strong class="example">示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/12/24/land2.jpg" style="width: 404px; height: 85px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>grid = [[1,1]]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>如果网格中都是水，也认为是分离的 ([[1,1]] -> [[0,0]])，0 岛屿。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>grid = [[1,0,1,0]]
|
||||
<strong>输出：</strong>0
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>grid = [[1,1,0,1,1],
|
||||
[1,1,1,1,1],
|
||||
[1,1,0,1,1],
|
||||
[1,1,0,1,1]]
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 5：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>grid = [[1,1,0,1,1],
|
||||
[1,1,1,1,1],
|
||||
[1,1,0,1,1],
|
||||
[1,1,1,1,1]]
|
||||
<strong>输出：</strong>2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= grid.length, grid[i].length <= 30</code></li>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 30</code></li>
|
||||
<li><code>grid[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,19 +1,19 @@
|
||||
<p>冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。</p>
|
||||
<p>冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。</p>
|
||||
|
||||
<p>在加热器的加热半径范围内的每个房屋都可以获得供暖。</p>
|
||||
|
||||
<p>现在，给出位于一条水平线上的房屋 <code>houses</code> 和供暖器 <code>heaters</code> 的位置，请你找出并返回可以覆盖所有房屋的最小加热半径。</p>
|
||||
<p>现在，给出位于一条水平线上的房屋 <code>houses</code> 和供暖器 <code>heaters</code> 的位置，请你找出并返回可以覆盖所有房屋的最小加热半径。</p>
|
||||
|
||||
<p><strong>说明</strong>：所有供暖器都遵循你的半径标准，加热的半径也一样。</p>
|
||||
<p><b>注意</b>：所有供暖器 <code>heaters</code> 都遵循你的半径标准，加热的半径也一样。</p>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> houses = [1,2,3], heaters = [2]
|
||||
<strong>输出:</strong> 1
|
||||
<strong>解释:</strong> 仅在位置2上有一个供暖器。如果我们将加热半径设为1，那么所有房屋就都能得到供暖。
|
||||
<strong>解释:</strong> 仅在位置 2 上有一个供暖器。如果我们将加热半径设为 1，那么所有房屋就都能得到供暖。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
@@ -21,7 +21,7 @@
|
||||
<pre>
|
||||
<strong>输入:</strong> houses = [1,2,3,4], heaters = [1,4]
|
||||
<strong>输出:</strong> 1
|
||||
<strong>解释:</strong> 在位置1, 4上有两个供暖器。我们需要将加热半径设为1，这样所有房屋就都能得到供暖。
|
||||
<strong>解释:</strong> 在位置 1, 4 上有两个供暖器。我们需要将加热半径设为 1，这样所有房屋就都能得到供暖。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
@@ -31,11 +31,11 @@
|
||||
<strong>输出：</strong>3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= houses.length, heaters.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= houses[i], heaters[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= houses.length, heaters.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= houses[i], heaters[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
<p>假设玩家在第 <code>i</code> 轮中击中 <code>x<sub>i</sub></code> 个瓶子。玩家第 <code>i</code> 轮的价值为：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果玩家在前两轮中击中了 <code>10</code> 个瓶子，则为 <code>2x<sub>i</sub></code> 。</li>
|
||||
<li>如果玩家在该轮的前两轮的任何一轮中击中了 <code>10</code> 个瓶子，则为 <code>2x<sub>i</sub></code> 。</li>
|
||||
<li>否则，为 <code>x<sub>i</sub></code> 。</li>
|
||||
</ul>
|
||||
|
||||
|
||||
@@ -7,21 +7,21 @@
|
||||
| user_id | int |
|
||||
| name | varchar |
|
||||
+----------------+---------+
|
||||
user_id 是该表的主键。
|
||||
user_id 是该表的主键(具有唯一值的列)。
|
||||
该表包含用户的 ID 和名字。名字仅由小写和大写字符组成。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>编写一个 SQL 查询来修复名字，使得只有第一个字符是大写的，其余都是小写的。</p>
|
||||
<p>编写解决方案，修复名字，使得只有第一个字符是大写的，其余都是小写的。</p>
|
||||
|
||||
<p>返回按 <code>user_id</code> 排序的结果表。</p>
|
||||
|
||||
<p>查询结果格式示例如下。</p>
|
||||
<p>返回结果格式示例如下。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<p><strong class="example">示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>
|
||||
|
||||
@@ -6,29 +6,30 @@
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>n = 7
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 7
|
||||
<strong>输出：</strong>21
|
||||
<strong>解释：</strong>在 <code>[1, 7]</code> 范围内能被 3、<code>5、</code><code>7 整除的所有整数分别是</code><code> 3、5、6、7</code> 。数字之和为 <code>21</code> 。
|
||||
<strong>解释：</strong>在 <code>[1, 7]</code> 范围内能被 <code>3</code>、<code>5</code>、<code>7</code> 整除的所有整数分别是 <code>3</code>、<code>5</code>、<code>6</code>、<code>7</code> 。数字之和为 <code>21</code>。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>n = 10
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 10
|
||||
<strong>输出：</strong>40
|
||||
<strong>解释：</strong>在 <code>[1, 10]</code> 范围内能被 3、<code>5、</code><code>7 整除的所有整数分别是</code><code> 3、5、6、7、9、10</code> 。数字之和为 <code>40</code> 。
|
||||
<strong>解释：</strong>在 <code>[1, 10]</code> 范围内能被 <code>3</code>、<code>5</code>、<code>7</code> 整除的所有整数分别是 <code>3</code>、<code>5</code>、<code>6</code>、<code>7</code>、<code>9</code>、<code>10</code> 。数字之和为 <code>40</code>。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>n = 9
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 9
|
||||
<strong>输出：</strong>30
|
||||
<strong>解释：</strong>在 <code>[1, 9]</code> 范围内能被 3、<code>5、</code><code>7 整除的所有整数分别是</code><code> 3、5、6、7、9</code> 。数字之和为 <code>30</code> 。
|
||||
<strong>解释：</strong>在 <code>[1, 9]</code> 范围内能被 <code>3</code>、<code>5</code>、<code>7</code> 整除的所有整数分别是 <code>3</code>、<code>5</code>、<code>6</code>、<code>7</code>、<code>9</code> 。数字之和为 <code>30</code>。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>3</sup></code></li>
|
||||
<li>1 <= n <= 10<sup>3</sup></li>
|
||||
</ul>
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
<p>一个厨师收集了他 <code>n</code> 道菜的满意程度 <code>satisfaction</code> ，这个厨师做出每道菜的时间都是 1 单位时间。</p>
|
||||
|
||||
<p>一道菜的 「喜爱时间」系数定义为烹饪这道菜以及之前每道菜所花费的时间乘以这道菜的满意程度，也就是 <code>time[i]</code>*<code>satisfaction[i]</code> 。</p>
|
||||
<p>一道菜的 「 <strong>like-time 系数 </strong>」定义为烹饪这道菜结束的时间（包含之前每道菜所花费的时间）乘以这道菜的满意程度，也就是 <code>time[i]</code>*<code>satisfaction[i]</code> 。</p>
|
||||
|
||||
<p>请你返回做完所有菜 「喜爱时间」总和的最大值为多少。</p>
|
||||
<p>返回厨师在准备了一定数量的菜肴后可以获得的最大 <strong>like-time 系数</strong> 总和。</p>
|
||||
|
||||
<p>你可以按 <strong>任意</strong> 顺序安排做菜的顺序，你也可以选择放弃做某些菜来获得更大的总和。</p>
|
||||
|
||||
@@ -13,14 +13,14 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>satisfaction = [-1,-8,0,5,-9]
|
||||
<strong>输出：</strong>14
|
||||
<strong>解释：</strong>去掉第二道和最后一道菜，最大的喜爱时间系数和为 (-1*1 + 0*2 + 5*3 = 14) 。每道菜都需要花费 1 单位时间完成。</pre>
|
||||
<strong>解释：</strong>去掉第二道和最后一道菜，最大的 like-time 系数和为 (-1*1 + 0*2 + 5*3 = 14) 。每道菜都需要花费 1 单位时间完成。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>satisfaction = [4,3,2]
|
||||
<strong>输出：</strong>20
|
||||
<strong>解释：</strong>按照原来顺序相反的时间做菜 (2*1 + 3*2 + 4*3 = 20)
|
||||
<strong>解释：可以</strong>按照任意顺序做菜 (2*1 + 3*2 + 4*3 = 20)
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
@@ -28,7 +28,7 @@
|
||||
<pre>
|
||||
<strong>输入：</strong>satisfaction = [-1,-4,-5]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>大家都不喜欢这些菜，所以不做任何菜可以获得最大的喜爱时间系数。
|
||||
<strong>解释：</strong>大家都不喜欢这些菜，所以不做任何菜就可以获得最大的 like-time 系数。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user