mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-13 03:11:42 +08:00
add leetcode problem-cn part6
This commit is contained in:
54
算法题（国内版）/problem (Chinese)/2 的幂 [power-of-two].html
Normal file
54
算法题（国内版）/problem (Chinese)/2 的幂 [power-of-two].html
Normal file
@@ -0,0 +1,54 @@
|
||||
<p>给你一个整数 <code>n</code>，请你判断该整数是否是 2 的幂次方。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p>如果存在一个整数 <code>x</code> 使得 <code>n == 2<sup>x</sup></code> ，则认为 <code>n</code> 是 2 的幂次方。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>2<sup>0</sup> = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 16
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>2<sup>4</sup> = 16
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 3
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 4
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 5：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 5
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你能够不使用循环/递归解决此问题吗？</p>
|
||||
45
算法题（国内版）/problem (Chinese)/3 的幂 [power-of-three].html
Normal file
45
算法题（国内版）/problem (Chinese)/3 的幂 [power-of-three].html
Normal file
@@ -0,0 +1,45 @@
|
||||
<p>给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p>整数 <code>n</code> 是 3 的幂次方需满足：存在整数 <code>x</code> 使得 <code>n == 3<sup>x</sup></code></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 27
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 0
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 9
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 45
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你能不使用循环或者递归来完成本题吗？</p>
|
||||
38
算法题（国内版）/problem (Chinese)/4的幂 [power-of-four].html
Normal file
38
算法题（国内版）/problem (Chinese)/4的幂 [power-of-four].html
Normal file
@@ -0,0 +1,38 @@
|
||||
<p>给定一个整数，写一个函数来判断它是否是 4 的幂次方。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p>整数 <code>n</code> 是 4 的幂次方需满足：存在整数 <code>x</code> 使得 <code>n == 4<sup>x</sup></code></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 16
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 5
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你能不使用循环或者递归来完成本题吗？</p>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>给你一个字符串 <code>columnTitle</code> ，表示 Excel 表格中的列名称。返回 <em>该列名称对应的列序号</em> 。</p>
|
||||
|
||||
<p>例如：</p>
|
||||
|
||||
<pre>
|
||||
A -> 1
|
||||
B -> 2
|
||||
C -> 3
|
||||
...
|
||||
Z -> 26
|
||||
AA -> 27
|
||||
AB -> 28
|
||||
...</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> columnTitle = "A"
|
||||
<strong>输出:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>columnTitle = "AB"
|
||||
<strong>输出:</strong> 28
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>columnTitle = "ZY"
|
||||
<strong>输出:</strong> 701</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= columnTitle.length <= 7</code></li>
|
||||
<li><code>columnTitle</code> 仅由大写英文组成</li>
|
||||
<li><code>columnTitle</code> 在范围 <code>["A", "FXSHRXW"]</code> 内</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>给你一个整数 <code>columnNumber</code> ，返回它在 Excel 表中相对应的列名称。</p>
|
||||
|
||||
<p>例如：</p>
|
||||
|
||||
<pre>
|
||||
A -> 1
|
||||
B -> 2
|
||||
C -> 3
|
||||
...
|
||||
Z -> 26
|
||||
AA -> 27
|
||||
AB -> 28
|
||||
...
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>columnNumber = 1
|
||||
<strong>输出：</strong>"A"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>columnNumber = 28
|
||||
<strong>输出：</strong>"AB"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>columnNumber = 701
|
||||
<strong>输出：</strong>"ZY"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>columnNumber = 2147483647
|
||||
<strong>输出：</strong>"FXSHRXW"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= columnNumber <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
38
算法题（国内版）/problem (Chinese)/Fizz Buzz [fizz-buzz].html
Normal file
38
算法题（国内版）/problem (Chinese)/Fizz Buzz [fizz-buzz].html
Normal file
@@ -0,0 +1,38 @@
|
||||
<p>给你一个整数 <code>n</code> ，找出从 <code>1</code> 到 <code>n</code> 各个整数的 Fizz Buzz 表示，并用字符串数组 <code>answer</code>（<strong>下标从 1 开始</strong>）返回结果，其中：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>answer[i] == "FizzBuzz"</code> 如果 <code>i</code> 同时是 <code>3</code> 和 <code>5</code> 的倍数。</li>
|
||||
<li><code>answer[i] == "Fizz"</code> 如果 <code>i</code> 是 <code>3</code> 的倍数。</li>
|
||||
<li><code>answer[i] == "Buzz"</code> 如果 <code>i</code> 是 <code>5</code> 的倍数。</li>
|
||||
<li><code>answer[i] == i</code> （以字符串形式）如果上述条件全不满足。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 3
|
||||
<strong>输出：</strong>["1","2","Fizz"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 5
|
||||
<strong>输出：</strong>["1","2","Fizz","4","Buzz"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 15
|
||||
<strong>输出：</strong>["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
35
算法题（国内版）/problem (Chinese)/H 指数 II [h-index-ii].html
Normal file
35
算法题（国内版）/problem (Chinese)/H 指数 II [h-index-ii].html
Normal file
@@ -0,0 +1,35 @@
|
||||
<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><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>请你设计并实现对数时间复杂度的算法解决此问题。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 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>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>citations = [1,2,100]
|
||||
<strong>输出：</strong>2
|
||||
</pre>
|
||||
|
||||
<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>citations</code> 按 <strong>升序排列</strong></li>
|
||||
</ul>
|
||||
32
算法题（国内版）/problem (Chinese)/H 指数 [h-index].html
Normal file
32
算法题（国内版）/problem (Chinese)/H 指数 [h-index].html
Normal file
@@ -0,0 +1,32 @@
|
||||
<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> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong><code>citations = [3,0,6,1,5]</code>
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>给定数组表示研究者总共有 <code>5</code> 篇论文，每篇论文相应的被引用了 <code>3, 0, 6, 1, 5</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>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>citations = [1,3,1]
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == citations.length</code></li>
|
||||
<li><code>1 <= n <= 5000</code></li>
|
||||
<li><code>0 <= citations[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,54 @@
|
||||
<p>给你一个链表，每 <em>k </em>个节点一组进行翻转，请你返回翻转后的链表。</p>
|
||||
|
||||
<p><em>k </em>是一个正整数，它的值小于或等于链表的长度。</p>
|
||||
|
||||
<p>如果节点总数不是 <em>k </em>的整数倍，那么请将最后剩余的节点保持原有顺序。</p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>你可以设计一个只使用常数额外空间的算法来解决此问题吗？</li>
|
||||
<li><strong>你不能只是单纯的改变节点内部的值</strong>，而是需要实际进行节点交换。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,2,3,4,5], k = 2
|
||||
<strong>输出：</strong>[2,1,4,3,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,2,3,4,5], k = 3
|
||||
<strong>输出：</strong>[3,2,1,4,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,2,3,4,5], k = 1
|
||||
<strong>输出：</strong>[1,2,3,4,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1], k = 1
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<ul>
|
||||
</ul>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>列表中节点的数量在范围 <code>sz</code> 内</li>
|
||||
<li><code>1 <= sz <= 5000</code></li>
|
||||
<li><code>0 <= Node.val <= 1000</code></li>
|
||||
<li><code>1 <= k <= sz</code></li>
|
||||
</ul>
|
||||
50
算法题（国内版）/problem (Chinese)/LRU 缓存 [lru-cache].html
Normal file
50
算法题（国内版）/problem (Chinese)/LRU 缓存 [lru-cache].html
Normal file
@@ -0,0 +1,50 @@
|
||||
<div class="title__3Vvk">请你设计并实现一个满足 <a href="https://baike.baidu.com/item/LRU" target="_blank">LRU (最近最少使用) 缓存</a> 约束的数据结构。</div>
|
||||
|
||||
<div class="title__3Vvk">实现 <code>LRUCache</code> 类：</div>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<ul>
|
||||
<li><code>LRUCache(int capacity)</code> 以 <strong>正整数</strong> 作为容量 <code>capacity</code> 初始化 LRU 缓存</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>value</code> ；如果不存在，则向缓存中插入该组 <code>key-value</code> 。如果插入操作导致关键字数量超过 <code>capacity</code> ，则应该 <strong>逐出</strong> 最久未使用的关键字。</li>
|
||||
</ul>
|
||||
|
||||
<p>函数 <code>get</code> 和 <code>put</code> 必须以 <code>O(1)</code> 的平均时间复杂度运行。</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入</strong>
|
||||
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
|
||||
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
|
||||
<strong>输出</strong>
|
||||
[null, null, null, 1, null, -1, null, -1, 3, 4]
|
||||
|
||||
<strong>解释</strong>
|
||||
LRUCache lRUCache = new LRUCache(2);
|
||||
lRUCache.put(1, 1); // 缓存是 {1=1}
|
||||
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
|
||||
lRUCache.get(1); // 返回 1
|
||||
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
|
||||
lRUCache.get(2); // 返回 -1 (未找到)
|
||||
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
|
||||
lRUCache.get(1); // 返回 -1 (未找到)
|
||||
lRUCache.get(3); // 返回 3
|
||||
lRUCache.get(4); // 返回 4
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= capacity <= 3000</code></li>
|
||||
<li><code>0 <= key <= 10000</code></li>
|
||||
<li><code>0 <= value <= 10<sup>5</sup></code></li>
|
||||
<li>最多调用 <code>2 * 10<sup>5</sup></code> 次 <code>get</code> 和 <code>put</code></li>
|
||||
</ul>
|
||||
34
算法题（国内版）/problem (Chinese)/N 皇后 [n-queens].html
Normal file
34
算法题（国内版）/problem (Chinese)/N 皇后 [n-queens].html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p><strong>n 皇后问题</strong> 研究的是如何将 <code>n</code> 个皇后放置在 <code>n×n</code> 的棋盘上，并且使皇后彼此之间不能相互攻击。</p>
|
||||
|
||||
<p>给你一个整数 <code>n</code> ，返回所有不同的 <strong>n<em> </em>皇后问题</strong> 的解决方案。</p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p>每一种解法包含一个不同的 <strong>n 皇后问题</strong> 的棋子放置方案，该方案中 <code>'Q'</code> 和 <code>'.'</code> 分别代表了皇后和空位。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 4
|
||||
<strong>输出：</strong>[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
|
||||
<strong>解释：</strong>如上图所示，4 皇后问题存在两个不同的解法。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>[["Q"]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 9</code></li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
46
算法题（国内版）/problem (Chinese)/Nim 游戏 [nim-game].html
Normal file
46
算法题（国内版）/problem (Chinese)/Nim 游戏 [nim-game].html
Normal file
@@ -0,0 +1,46 @@
|
||||
<p>你和你的朋友，两个人一起玩 <a href="https://baike.baidu.com/item/Nim游戏/6737105" target="_blank">Nim 游戏</a>：</p>
|
||||
|
||||
<ul>
|
||||
<li>桌子上有一堆石头。</li>
|
||||
<li>你们轮流进行自己的回合， <strong>你作为先手 </strong>。</li>
|
||||
<li>每一回合，轮到的人拿掉 1 - 3 块石头。</li>
|
||||
<li>拿掉最后一块石头的人就是获胜者。</li>
|
||||
</ul>
|
||||
|
||||
<p>假设你们每一步都是最优解。请编写一个函数，来判断你是否可以在给定石头数量为 <code>n</code> 的情况下赢得游戏。如果可以赢，返回 <code>true</code>；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong><code>n = 4</code>
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：</strong>以下是可能的结果:
|
||||
1. 移除1颗石头。你的朋友移走了3块石头，包括最后一块。你的朋友赢了。
|
||||
2. 移除2个石子。你的朋友移走2块石头，包括最后一块。你的朋友赢了。
|
||||
3.你移走3颗石子。你的朋友移走了最后一块石头。你的朋友赢了。
|
||||
在所有结果中，你的朋友是赢家。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 2
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
32
算法题（国内版）/problem (Chinese)/N皇后 II [n-queens-ii].html
Normal file
32
算法题（国内版）/problem (Chinese)/N皇后 II [n-queens-ii].html
Normal file
@@ -0,0 +1,32 @@
|
||||
<p><strong>n 皇后问题</strong> 研究的是如何将 <code>n</code> 个皇后放置在 <code>n × n</code> 的棋盘上，并且使皇后彼此之间不能相互攻击。</p>
|
||||
|
||||
<p>给你一个整数 <code>n</code> ，返回 <strong>n 皇后问题</strong> 不同的解决方案的数量。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 4
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>如上图所示，4 皇后问题存在两个不同的解法。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 9</code></li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p><code>RandomizedCollection</code> 是一种包含数字集合(可能是重复的)的数据结构。它应该支持插入和删除特定元素，以及删除随机元素。</p>
|
||||
|
||||
<p>实现 <code>RandomizedCollection</code> 类:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RandomizedCollection()</code>初始化空的 <code>RandomizedCollection</code> 对象。</li>
|
||||
<li><code>bool insert(int val)</code> 将一个 <code>val</code> 项插入到集合中，即使该项已经存在。如果该项不存在，则返回 <code>true</code> ，否则返回 <code>false</code> 。</li>
|
||||
<li><code>bool remove(int val)</code> 如果存在，从集合中移除一个 <code>val</code> 项。如果该项存在，则返回 <code>true</code> ，否则返回 <code>false</code> 。注意，如果 <code>val</code> 在集合中出现多次，我们只删除其中一个。</li>
|
||||
<li><code>int getRandom()</code> 从当前的多个元素集合中返回一个随机元素。每个元素被返回的概率与集合中包含的相同值的数量 <strong>线性相关</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>您必须实现类的函数，使每个函数的 <strong>平均</strong> 时间复杂度为 <code>O(1)</code> 。</p>
|
||||
|
||||
<p><strong>注意：</strong>生成测试用例时，只有在 <code>RandomizedCollection</code> 中 <strong>至少有一项</strong> 时，才会调用 <code>getRandom</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入</strong>
|
||||
["RandomizedCollection", "insert", "insert", "insert", "getRandom", "remove", "getRandom"]
|
||||
[[], [1], [1], [2], [], [1], []]
|
||||
<strong>输出</strong>
|
||||
[null, true, false, true, 2, true, 1]
|
||||
|
||||
<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>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code></li>
|
||||
<li><code>insert</code>, <code>remove</code> 和 <code>getRandom</code> 最多 <strong>总共</strong> 被调用 <code>2 * 10<sup>5</sup></code> 次</li>
|
||||
<li>当调用 <code>getRandom</code> 时，数据结构中 <strong>至少有一个</strong> 元素</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>实现<code>RandomizedSet</code> 类：</p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<ul>
|
||||
<li><code>RandomizedSet()</code> 初始化 <code>RandomizedSet</code> 对象</li>
|
||||
<li><code>bool insert(int val)</code> 当元素 <code>val</code> 不存在时，向集合中插入该项，并返回 <code>true</code> ；否则，返回 <code>false</code> 。</li>
|
||||
<li><code>bool remove(int val)</code> 当元素 <code>val</code> 存在时，从集合中移除该项，并返回 <code>true</code> ；否则，返回 <code>false</code> 。</li>
|
||||
<li><code>int getRandom()</code> 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 <strong>相同的概率</strong> 被返回。</li>
|
||||
</ul>
|
||||
|
||||
<p>你必须实现类的所有函数，并满足每个函数的 <strong>平均</strong> 时间复杂度为 <code>O(1)</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入</strong>
|
||||
["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
|
||||
[[], [1], [2], [2], [], [1], [2], []]
|
||||
<strong>输出</strong>
|
||||
[null, true, false, true, 2, true, false, 2]
|
||||
|
||||
<strong>解释</strong>
|
||||
RandomizedSet randomizedSet = new RandomizedSet();
|
||||
randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
|
||||
randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
|
||||
randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
|
||||
randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
|
||||
randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
|
||||
randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
|
||||
randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code></li>
|
||||
<li>最多调用 <code>insert</code>、<code>remove</code> 和 <code>getRandom</code> 函数 <code>2 * </code><code>10<sup>5</sup></code> 次</li>
|
||||
<li>在调用 <code>getRandom</code> 方法时，数据结构中 <strong>至少存在一个</strong> 元素。</li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
35
算法题（国内版）/problem (Chinese)/Pow(x, n) [powx-n].html
Normal file
35
算法题（国内版）/problem (Chinese)/Pow(x, n) [powx-n].html
Normal file
@@ -0,0 +1,35 @@
|
||||
<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>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 2.00000, n = 10
|
||||
<strong>输出：</strong>1024.00000
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 2.10000, n = 3
|
||||
<strong>输出：</strong>9.26100
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 2.00000, n = -2
|
||||
<strong>输出：</strong>0.25000
|
||||
<strong>解释：</strong>2<sup>-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25
|
||||
</pre>
|
||||
|
||||
<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>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>给定一个表示数据的整数数组 <code>data</code> ，返回它是否为有效的 <strong>UTF-8</strong> 编码。</p>
|
||||
|
||||
<p><strong>UTF-8</strong> 中的一个字符可能的长度为 <strong>1 到 4 字节</strong>，遵循以下的规则：</p>
|
||||
|
||||
<ol>
|
||||
<li>对于 <strong>1 字节</strong> 的字符，字节的第一位设为 0 ，后面 7 位为这个符号的 unicode 码。</li>
|
||||
<li>对于 <strong>n 字节</strong> 的字符 (n > 1)，第一个字节的前 n 位都设为1，第 n+1 位设为 0 ，后面字节的前两位一律设为 10 。剩下的没有提及的二进制位，全部为这个符号的 unicode 码。</li>
|
||||
</ol>
|
||||
|
||||
<p>这是 UTF-8 编码的工作方式：</p>
|
||||
|
||||
<pre>
|
||||
<code> Char. number range | UTF-8 octet sequence
|
||||
(hexadecimal) | (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
|
||||
</code></pre>
|
||||
|
||||
<p><strong>注意：</strong>输入是整数数组。只有每个整数的 <strong>最低 8 个有效位</strong> 用来存储数据。这意味着每个整数只表示 1 字节的数据。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>data = [197,130,1]
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>数据表示字节序列:<strong>11000101 10000010 00000001</strong>。
|
||||
这是有效的 utf-8 编码，为一个 2 字节字符，跟着一个 1 字节字符。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>data = [235,140,4]
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：</strong>数据表示 8 位的序列: <strong>11101011 10001100 00000100</strong>.
|
||||
前 3 位都是 1 ，第 4 位为 0 表示它是一个 3 字节字符。
|
||||
下一个字节是开头为 10 的延续字节，这是正确的。
|
||||
但第二个延续字节不以 10 开头，所以是不符合规则的。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= data.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= data[i] <= 255</code></li>
|
||||
</ul>
|
||||
52
算法题（国内版）/problem (Chinese)/Z 字形变换 [zigzag-conversion].html
Normal file
52
算法题（国内版）/problem (Chinese)/Z 字形变换 [zigzag-conversion].html
Normal file
@@ -0,0 +1,52 @@
|
||||
<p>将一个给定字符串 <code>s</code> 根据给定的行数 <code>numRows</code> ，以从上往下、从左到右进行 Z 字形排列。</p>
|
||||
|
||||
<p>比如输入字符串为 <code>"PAYPALISHIRING"</code> 行数为 <code>3</code> 时，排列如下：</p>
|
||||
|
||||
<pre>
|
||||
P A H N
|
||||
A P L S I I G
|
||||
Y I R</pre>
|
||||
|
||||
<p>之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：<code>"PAHNAPLSIIGYIR"</code>。</p>
|
||||
|
||||
<p>请你实现这个将字符串进行指定行数变换的函数：</p>
|
||||
|
||||
<pre>
|
||||
string convert(string s, int numRows);</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "PAYPALISHIRING", numRows = 3
|
||||
<strong>输出：</strong>"PAHNAPLSIIGYIR"
|
||||
</pre>
|
||||
<strong>示例 2：</strong>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "PAYPALISHIRING", numRows = 4
|
||||
<strong>输出：</strong>"PINALSIGYAHRPI"
|
||||
<strong>解释：</strong>
|
||||
P I N
|
||||
A L S I G
|
||||
Y A H R
|
||||
P I
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "A", numRows = 1
|
||||
<strong>输出：</strong>"A"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s</code> 由英文字母（小写和大写）、<code>','</code> 和 <code>'.'</code> 组成</li>
|
||||
<li><code>1 <= numRows <= 1000</code></li>
|
||||
</ul>
|
||||
30
算法题（国内版）/problem (Chinese)/x 的平方根 [sqrtx].html
Normal file
30
算法题（国内版）/problem (Chinese)/x 的平方根 [sqrtx].html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>给你一个非负整数 <code>x</code> ，计算并返回 <code>x</code> 的 <strong>算术平方根</strong> 。</p>
|
||||
|
||||
<p>由于返回类型是整数，结果只保留 <strong>整数部分 </strong>，小数部分将被 <strong>舍去 。</strong></p>
|
||||
|
||||
<p><strong>注意：</strong>不允许使用任何内置指数函数和算符，例如 <code>pow(x, 0.5)</code> 或者 <code>x ** 0.5</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 4
|
||||
<strong>输出：</strong>2
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>x = 8
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= x <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
35
算法题（国内版）/problem (Chinese)/三数之和 [3sum].html
Normal file
35
算法题（国内版）/problem (Chinese)/三数之和 [3sum].html
Normal file
@@ -0,0 +1,35 @@
|
||||
<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><strong>注意：</strong>答案中不可以包含重复的三元组。</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]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0]
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<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>
|
||||
</ul>
|
||||
44
算法题（国内版）/problem (Chinese)/三角形最小路径和 [triangle].html
Normal file
44
算法题（国内版）/problem (Chinese)/三角形最小路径和 [triangle].html
Normal file
@@ -0,0 +1,44 @@
|
||||
<p>给定一个三角形 <code>triangle</code> ，找出自顶向下的最小路径和。</p>
|
||||
|
||||
<p>每一步只能移动到下一行中相邻的结点上。<strong>相邻的结点 </strong>在这里指的是 <strong>下标</strong> 与 <strong>上一层结点下标</strong> 相同或者等于 <strong>上一层结点下标 + 1</strong> 的两个结点。也就是说，如果正位于当前行的下标 <code>i</code> ，那么下一步可以移动到下一行的下标 <code>i</code> 或 <code>i + 1</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
|
||||
<strong>输出：</strong>11
|
||||
<strong>解释：</strong>如下面简图所示：
|
||||
<strong>2</strong>
|
||||
<strong>3</strong> 4
|
||||
6 <strong>5</strong> 7
|
||||
4 <strong>1</strong> 8 3
|
||||
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>triangle = [[-10]]
|
||||
<strong>输出：</strong>-10
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= triangle.length <= 200</code></li>
|
||||
<li><code>triangle[0].length == 1</code></li>
|
||||
<li><code>triangle[i].length == triangle[i - 1].length + 1</code></li>
|
||||
<li><code>-10<sup>4</sup> <= triangle[i][j] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>你可以只使用 <code>O(n)</code> 的额外空间（<code>n</code> 为三角形的总行数）来解决这个问题吗？</li>
|
||||
</ul>
|
||||
50
算法题（国内版）/problem (Chinese)/上升的温度 [rising-temperature].html
Normal file
50
算法题（国内版）/problem (Chinese)/上升的温度 [rising-temperature].html
Normal file
@@ -0,0 +1,50 @@
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p>表： <code>Weather</code></p>
|
||||
|
||||
<pre>
|
||||
+---------------+---------+
|
||||
| Column Name | Type |
|
||||
+---------------+---------+
|
||||
| id | int |
|
||||
| recordDate | date |
|
||||
| temperature | int |
|
||||
+---------------+---------+
|
||||
id 是这个表的主键
|
||||
该表包含特定日期的温度信息</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>编写一个 SQL 查询，来查找与之前（昨天的）日期相比温度更高的所有日期的 <code>id</code> 。</p>
|
||||
|
||||
<p>返回结果 <strong>不要求顺序</strong> 。</p>
|
||||
|
||||
<p>查询结果格式如下例。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<code><strong>输入：</strong>
|
||||
Weather 表：</code>
|
||||
+----+------------+-------------+
|
||||
| id | recordDate | Temperature |
|
||||
+----+------------+-------------+
|
||||
| 1 | 2015-01-01 | 10 |
|
||||
| 2 | 2015-01-02 | 25 |
|
||||
| 3 | 2015-01-03 | 20 |
|
||||
| 4 | 2015-01-04 | 30 |
|
||||
+----+------------+-------------+
|
||||
<strong>输出：</strong>
|
||||
+----+
|
||||
| id |
|
||||
+----+
|
||||
| 2 |
|
||||
| 4 |
|
||||
+----+
|
||||
<strong>解释：</strong>
|
||||
2015-01-02 的温度比前一天高（10 -> 25）
|
||||
2015-01-04 的温度比前一天高（20 -> 30）</pre>
|
||||
</div>
|
||||
</div>
|
||||
49
算法题（国内版）/problem (Chinese)/下一个排列 [next-permutation].html
Normal file
49
算法题（国内版）/problem (Chinese)/下一个排列 [next-permutation].html
Normal file
@@ -0,0 +1,49 @@
|
||||
<p>整数数组的一个 <strong>排列</strong> 就是将其所有成员以序列或线性顺序排列。</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，<code>arr = [1,2,3]</code> ，以下这些都可以视作 <code>arr</code> 的排列：<code>[1,2,3]</code>、<code>[1,3,2]</code>、<code>[3,1,2]</code>、<code>[2,3,1]</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>整数数组的 <strong>下一个排列</strong> 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 <strong>下一个排列</strong> 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，<code>arr = [1,2,3]</code> 的下一个排列是 <code>[1,3,2]</code> 。</li>
|
||||
<li>类似地，<code>arr = [2,3,1]</code> 的下一个排列是 <code>[3,1,2]</code> 。</li>
|
||||
<li>而 <code>arr = [3,2,1]</code> 的下一个排列是 <code>[1,2,3]</code> ，因为 <code>[3,2,1]</code> 不存在一个字典序更大的排列。</li>
|
||||
</ul>
|
||||
|
||||
<p>给你一个整数数组 <code>nums</code> ，找出 <code>nums</code> 的下一个排列。</p>
|
||||
|
||||
<p>必须<strong><a href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank"> 原地 </a></strong>修改，只允许使用额外常数空间。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3]
|
||||
<strong>输出：</strong>[1,3,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,2,1]
|
||||
<strong>输出：</strong>[1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,1,5]
|
||||
<strong>输出：</strong>[1,5,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>0 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,29 @@
|
||||
<p>给你一个整数 <code>n</code> ，请你生成并返回所有由 <code>n</code> 个节点组成且节点值从 <code>1</code> 到 <code>n</code> 互不相同的不同 <strong>二叉搜索树</strong><em> </em>。可以按 <strong>任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg" style="width: 600px; height: 148px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 3
|
||||
<strong>输出：</strong>[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>[[1]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 8</code></li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
@@ -0,0 +1,25 @@
|
||||
<p>给你一个整数 <code>n</code> ，求恰由 <code>n</code> 个节点组成且节点值从 <code>1</code> 到 <code>n</code> 互不相同的 <strong>二叉搜索树</strong> 有多少种？返回满足题意的二叉搜索树的种数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg" style="width: 600px; height: 148px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 3
|
||||
<strong>输出：</strong>5
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 19</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>给定一个字符串 <code>s</code><strong> </strong>和一个字符串 <code>t</code> ，计算在 <code>s</code> 的子序列中 <code>t</code> 出现的个数。</p>
|
||||
|
||||
<p>字符串的一个 <strong>子序列</strong> 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，<code>"ACE"</code> 是 <code>"ABCDE"</code> 的一个子序列，而 <code>"AEC"</code> 不是）</p>
|
||||
|
||||
<p>题目数据保证答案符合 32 位带符号整数范围。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "rabbbit", t = "rabbit"<code>
|
||||
<strong>输出</strong></code><strong>：</strong><code>3
|
||||
</code><strong>解释：</strong>
|
||||
如下图所示, 有 3 种可以从 s 中得到 <code>"rabbit" 的方案</code>。
|
||||
<code><strong><u>rabb</u></strong>b<strong><u>it</u></strong></code>
|
||||
<code><strong><u>ra</u></strong>b<strong><u>bbit</u></strong></code>
|
||||
<code><strong><u>rab</u></strong>b<strong><u>bit</u></strong></code></pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "babgbag", t = "bag"
|
||||
<code><strong>输出</strong></code><strong>：</strong><code>5
|
||||
</code><strong>解释：</strong>
|
||||
如下图所示, 有 5 种可以从 s 中得到 <code>"bag" 的方案</code>。
|
||||
<code><strong><u>ba</u></strong>b<u><strong>g</strong></u>bag</code>
|
||||
<code><strong><u>ba</u></strong>bgba<strong><u>g</u></strong></code>
|
||||
<code><u><strong>b</strong></u>abgb<strong><u>ag</u></strong></code>
|
||||
<code>ba<u><strong>b</strong></u>gb<u><strong>ag</strong></u></code>
|
||||
<code>babg<strong><u>bag</u></strong></code>
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= s.length, t.length <= 1000</code></li>
|
||||
<li><code>s</code> 和 <code>t</code> 由英文字母组成</li>
|
||||
</ul>
|
||||
38
算法题（国内版）/problem (Chinese)/不同路径 II [unique-paths-ii].html
Normal file
38
算法题（国内版）/problem (Chinese)/不同路径 II [unique-paths-ii].html
Normal file
@@ -0,0 +1,38 @@
|
||||
<p>一个机器人位于一个<meta charset="UTF-8" /> <code>m x n</code> 网格的左上角 （起始点在下图中标记为 “Start” ）。</p>
|
||||
|
||||
<p>机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。</p>
|
||||
|
||||
<p>现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？</p>
|
||||
|
||||
<p>网格中的障碍物和空位置分别用 <code>1</code> 和 <code>0</code> 来表示。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg" />
|
||||
<pre>
|
||||
<strong>输入：</strong>obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
|
||||
<strong>输出：</strong>2
|
||||
<strong>解释：</strong>3x3 网格的正中间有一个障碍物。
|
||||
从左上角到右下角一共有 <code>2</code> 条不同的路径：
|
||||
1. 向右 -> 向右 -> 向下 -> 向下
|
||||
2. 向下 -> 向下 -> 向右 -> 向右
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg" />
|
||||
<pre>
|
||||
<strong>输入：</strong>obstacleGrid = [[0,1],[0,0]]
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == obstacleGrid.length</code></li>
|
||||
<li><code>n == obstacleGrid[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 100</code></li>
|
||||
<li><code>obstacleGrid[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
|
||||
</ul>
|
||||
47
算法题（国内版）/problem (Chinese)/不同路径 [unique-paths].html
Normal file
47
算法题（国内版）/problem (Chinese)/不同路径 [unique-paths].html
Normal file
@@ -0,0 +1,47 @@
|
||||
<p>一个机器人位于一个 <code>m x n</code><em> </em>网格的左上角 （起始点在下图中标记为 “Start” ）。</p>
|
||||
|
||||
<p>机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。</p>
|
||||
|
||||
<p>问总共有多少条不同的路径？</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img src="https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png" />
|
||||
<pre>
|
||||
<strong>输入：</strong>m = 3, n = 7
|
||||
<strong>输出：</strong>28</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>m = 3, n = 2
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>
|
||||
从左上角开始，总共有 3 条路径可以到达右下角。
|
||||
1. 向右 -> 向下 -> 向下
|
||||
2. 向下 -> 向下 -> 向右
|
||||
3. 向下 -> 向右 -> 向下
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>m = 7, n = 3
|
||||
<strong>输出：</strong>28
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>m = 3, n = 3
|
||||
<strong>输出：</strong>6</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= m, n <= 100</code></li>
|
||||
<li>题目数据保证答案小于等于 <code>2 * 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
29
算法题（国内版）/problem (Chinese)/丑数 II [ugly-number-ii].html
Normal file
29
算法题（国内版）/problem (Chinese)/丑数 II [ugly-number-ii].html
Normal file
@@ -0,0 +1,29 @@
|
||||
<p>给你一个整数 <code>n</code> ，请你找出并返回第 <code>n</code> 个 <strong>丑数</strong> 。</p>
|
||||
|
||||
<p><strong>丑数 </strong>就是只包含质因数 <code>2</code>、<code>3</code> 和/或 <code>5</code> 的正整数。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 10
|
||||
<strong>输出：</strong>12
|
||||
<strong>解释：</strong>[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>1 通常被视为丑数。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1690</code></li>
|
||||
</ul>
|
||||
35
算法题（国内版）/problem (Chinese)/丑数 [ugly-number].html
Normal file
35
算法题（国内版）/problem (Chinese)/丑数 [ugly-number].html
Normal file
@@ -0,0 +1,35 @@
|
||||
<p><strong>丑数 </strong>就是只包含质因数 <code>2</code>、<code>3</code> 和 <code>5</code> 的正整数。</p>
|
||||
|
||||
<p>给你一个整数 <code>n</code> ，请你判断 <code>n</code> 是否为 <strong>丑数</strong> 。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 6
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>6 = 2 × 3</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 1
|
||||
<strong>输出：</strong>true
|
||||
<strong>解释：</strong>1 没有质因数，因此它的全部质因数是 {2, 3, 5} 的空集。习惯上将其视作第一个丑数。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>n = 14
|
||||
<strong>输出：</strong>false
|
||||
<strong>解释：</strong>14 不是丑数，因为它包含了另外一个质因数 <code>7 </code>。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
49
算法题（国内版）/problem (Chinese)/丢失的数字 [missing-number].html
Normal file
49
算法题（国内版）/problem (Chinese)/丢失的数字 [missing-number].html
Normal file
@@ -0,0 +1,49 @@
|
||||
<p>给定一个包含 <code>[0, n]</code> 中 <code>n</code> 个数的数组 <code>nums</code> ，找出 <code>[0, n]</code> 这个范围内没有出现在数组中的那个数。</p>
|
||||
|
||||
<ul>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,0,1]
|
||||
<strong>输出：</strong>2
|
||||
<b>解释：</b>n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2 是丢失的数字，因为它没有出现在 nums 中。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0,1]
|
||||
<strong>输出：</strong>2
|
||||
<b>解释：</b>n = 2，因为有 2 个数字，所以所有的数字都在范围 [0,2] 内。2 是丢失的数字，因为它没有出现在 nums 中。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [9,6,4,2,3,5,7,0,1]
|
||||
<strong>输出：</strong>8
|
||||
<b>解释：</b>n = 9，因为有 9 个数字，所以所有的数字都在范围 [0,9] 内。8 是丢失的数字，因为它没有出现在 nums 中。</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0]
|
||||
<strong>输出：</strong>1
|
||||
<b>解释：</b>n = 1，因为有 1 个数字，所以所有的数字都在范围 [0,1] 内。1 是丢失的数字，因为它没有出现在 nums 中。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= n</code></li>
|
||||
<li><code>nums</code> 中的所有数字都 <strong>独一无二</strong></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你能否实现线性时间复杂度、仅使用额外常数空间的算法解决此问题?</p>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg" style="width: 422px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,2,3,4]
|
||||
<strong>输出：</strong>[2,1,4,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>链表中节点的数目在范围 <code>[0, 100]</code> 内</li>
|
||||
<li><code>0 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>给你两个整数数组 <code>nums1</code> 和 <code>nums2</code> ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums1 = [1,2,2,1], nums2 = [2,2]
|
||||
<strong>输出：</strong>[2,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums1 = [4,9,5], nums2 = [9,4,9,8,4]
|
||||
<strong>输出：</strong>[4,9]</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 1000</code></li>
|
||||
<li><code>0 <= nums1[i], nums2[i] <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong><strong>进阶</strong>：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>如果给定的数组已经排好序呢？你将如何优化你的算法？</li>
|
||||
<li>如果 <code>nums1</code><em> </em>的大小比 <code>nums2</code> 小，哪种方法更优？</li>
|
||||
<li>如果 <code>nums2</code><em> </em>的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>给定两个数组 <code>nums1</code> 和 <code>nums2</code> ，返回 <em>它们的交集</em> 。输出结果中的每个元素一定是 <strong>唯一</strong> 的。我们可以 <strong>不考虑输出结果的顺序</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums1 = [1,2,2,1], nums2 = [2,2]
|
||||
<strong>输出：</strong>[2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums1 = [4,9,5], nums2 = [9,4,9,8,4]
|
||||
<strong>输出：</strong>[9,4]
|
||||
<strong>解释：</strong>[4,9] 也是可通过的
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums1.length, nums2.length <= 1000</code></li>
|
||||
<li><code>0 <= nums1[i], nums2[i] <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>给你一个下标从 <strong>1</strong> 开始的整数数组 <code>numbers</code> ，该数组已按<strong><em> </em>非递减顺序排列 </strong>，请你从数组中找出满足相加之和等于目标数 <code>target</code> 的两个数。如果设这两个数分别是 <code>numbers[index<sub>1</sub>]</code> 和 <code>numbers[index<sub>2</sub>]</code> ，则 <code>1 <= index<sub>1</sub> < index<sub>2</sub> <= numbers.length</code> 。</p>
|
||||
|
||||
<p>以长度为 2 的整数数组 <code>[index<sub>1</sub>, index<sub>2</sub>]</code> 的形式返回这两个整数的下标 <code>index<sub>1</sub></code><em> </em>和<em> </em><code>index<sub>2</sub></code>。</p>
|
||||
|
||||
<p>你可以假设每个输入 <strong>只对应唯一的答案</strong> ，而且你 <strong>不可以</strong> 重复使用相同的元素。</p>
|
||||
|
||||
<p>你所设计的解决方案必须只使用常量级的额外空间。</p>
|
||||
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numbers = [<strong><em>2</em></strong>,<strong><em>7</em></strong>,11,15], target = 9
|
||||
<strong>输出：</strong>[1,2]
|
||||
<strong>解释：</strong>2 与 7 之和等于目标数 9 。因此 index<sub>1</sub> = 1, index<sub>2</sub> = 2 。返回 [1, 2] 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numbers = [<strong><em>2</em></strong>,3,<strong><em>4</em></strong>], target = 6
|
||||
<strong>输出：</strong>[1,3]
|
||||
<strong>解释：</strong>2 与 4 之和等于目标数 6 。因此 index<sub>1</sub> = 1, index<sub>2</sub> = 3 。返回 [1, 3] 。</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numbers = [<strong><em>-1</em></strong>,<strong><em>0</em></strong>], target = -1
|
||||
<strong>输出：</strong>[1,2]
|
||||
<strong>解释：</strong>-1 与 0 之和等于目标数 -1 。因此 index<sub>1</sub> = 1, index<sub>2</sub> = 2 。返回 [1, 2] 。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<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>-1000 <= target <= 1000</code></li>
|
||||
<li><strong>仅存在一个有效答案</strong></li>
|
||||
</ul>
|
||||
42
算法题（国内版）/problem (Chinese)/两数之和 [two-sum].html
Normal file
42
算法题（国内版）/problem (Chinese)/两数之和 [two-sum].html
Normal file
@@ -0,0 +1,42 @@
|
||||
<p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code>，请你在该数组中找出 <strong>和为目标值 </strong><em><code>target</code></em> 的那 <strong>两个</strong> 整数，并返回它们的数组下标。</p>
|
||||
|
||||
<p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p>
|
||||
|
||||
<p>你可以按任意顺序返回答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,7,11,15], target = 9
|
||||
<strong>输出：</strong>[0,1]
|
||||
<strong>解释：</strong>因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,2,4], target = 6
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,3], target = 6
|
||||
<strong>输出：</strong>[0,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
|
||||
<li><strong>只会存在一个有效答案</strong></li>
|
||||
</ul>
|
||||
|
||||
<p><strong>进阶：</strong>你可以想出一个时间复杂度小于 <code>O(n<sup>2</sup>)</code> 的算法吗？</p>
|
||||
39
算法题（国内版）/problem (Chinese)/两数相加 [add-two-numbers].html
Normal file
39
算法题（国内版）/problem (Chinese)/两数相加 [add-two-numbers].html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>给你两个 <strong>非空</strong> 的链表，表示两个非负的整数。它们每位数字都是按照 <strong>逆序</strong> 的方式存储的，并且每个节点只能存储 <strong>一位</strong> 数字。</p>
|
||||
|
||||
<p>请你将两个数相加，并以相同形式返回一个表示和的链表。</p>
|
||||
|
||||
<p>你可以假设除了数字 0 之外，这两个数都不会以 0 开头。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/01/02/addtwonumber1.jpg" style="width: 483px; height: 342px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [2,4,3], l2 = [5,6,4]
|
||||
<strong>输出：</strong>[7,0,8]
|
||||
<strong>解释：</strong>342 + 465 = 807.
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [0], l2 = [0]
|
||||
<strong>输出：</strong>[0]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
|
||||
<strong>输出：</strong>[8,9,9,9,0,0,0,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>每个链表中的节点数在范围 <code>[1, 100]</code> 内</li>
|
||||
<li><code>0 <= Node.val <= 9</code></li>
|
||||
<li>题目数据保证列表表示的数字不含前导零</li>
|
||||
</ul>
|
||||
29
算法题（国内版）/problem (Chinese)/两数相除 [divide-two-integers].html
Normal file
29
算法题（国内版）/problem (Chinese)/两数相除 [divide-two-integers].html
Normal file
@@ -0,0 +1,29 @@
|
||||
<p>给定两个整数，被除数 <code>dividend</code> 和除数 <code>divisor</code>。将两数相除，要求不使用乘法、除法和 mod 运算符。</p>
|
||||
|
||||
<p>返回被除数 <code>dividend</code> 除以除数 <code>divisor</code> 得到的商。</p>
|
||||
|
||||
<p>整数除法的结果应当截去（<code>truncate</code>）其小数部分，例如：<code>truncate(8.345) = 8</code> 以及 <code>truncate(-2.7335) = -2</code></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> dividend = 10, divisor = 3
|
||||
<strong>输出:</strong> 3
|
||||
<strong>解释: </strong>10/3 = truncate(3.33333..) = truncate(3) = 3</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> dividend = 7, divisor = -3
|
||||
<strong>输出:</strong> -2
|
||||
<strong>解释:</strong> 7/-3 = truncate(-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>
|
||||
</ul>
|
||||
25
算法题（国内版）/problem (Chinese)/两整数之和 [sum-of-two-integers].html
Normal file
25
算法题（国内版）/problem (Chinese)/两整数之和 [sum-of-two-integers].html
Normal file
@@ -0,0 +1,25 @@
|
||||
<p>给你两个整数 <code>a</code> 和 <code>b</code> ，<strong>不使用 </strong>运算符 <code>+</code> 和 <code>-</code> ，计算并返回两整数之和。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>a = 1, b = 2
|
||||
<strong>输出：</strong>3
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>a = 2, b = 3
|
||||
<strong>输出：</strong>5
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-1000 <= a, b <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<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>words</code><strong> </strong>中的单词完全匹配，<strong>中间不能有其他字符 </strong>，但不需要考虑 <code>words</code><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] 也是有效答案。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
|
||||
<code><strong>输出：</strong>[]</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
|
||||
<strong>输出：</strong>[6,9,12]
|
||||
</pre>
|
||||
|
||||
<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>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>给你一个由数字和运算符组成的字符串 <code>expression</code> ，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以 <strong>按任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>expression = "2-1-1"
|
||||
<strong>输出：</strong>[0,2]
|
||||
<strong>解释：</strong>
|
||||
((2-1)-1) = 0
|
||||
(2-(1-1)) = 2
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>expression = "2*3-4*5"
|
||||
<strong>输出：</strong>[-34,-14,-10,-10,10]
|
||||
<strong>解释：</strong>
|
||||
(2*(3-(4*5))) = -34
|
||||
((2*3)-(4*5)) = -14
|
||||
((2*(3-4))*5) = -10
|
||||
(2*((3-4)*5)) = -10
|
||||
(((2*3)-4)*5) = 10
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= expression.length <= 20</code></li>
|
||||
<li><code>expression</code> 由数字和算符 <code>'+'</code>、<code>'-'</code> 和 <code>'*'</code> 组成。</li>
|
||||
<li>输入表达式中的所有整数值在范围 <code>[0, 99]</code> </li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>给你一个整数数组 <code>nums</code> ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。</p>
|
||||
|
||||
<p>测试用例的答案是一个 <strong>32-位</strong> 整数。</p>
|
||||
|
||||
<p><strong>子数组</strong> 是数组的连续子序列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> nums = [2,3,-2,4]
|
||||
<strong>输出:</strong> <code>6</code>
|
||||
<strong>解释:</strong> 子数组 [2,3] 有最大乘积 6。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> nums = [-2,0,-1]
|
||||
<strong>输出:</strong> 0
|
||||
<strong>解释:</strong> 结果不能为 2, 因为 [-2,-1] 不是子数组。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>-10 <= nums[i] <= 10</code></li>
|
||||
<li><code>nums</code> 的任何前缀或后缀的乘积都 <strong>保证</strong> 是一个 <strong>32-位</strong> 整数</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>给定一个数组 <code>prices</code> ，其中 <code>prices[i]</code> 表示股票第 <code>i</code> 天的价格。</p>
|
||||
|
||||
<p>在每一天，你可能会决定购买和/或出售股票。你在任何时候 <strong>最多</strong> 只能持有 <strong>一股</strong> 股票。你也可以购买它，然后在 <strong>同一天</strong> 出售。<br />
|
||||
返回 <em>你能获得的 <strong>最大</strong> 利润</em> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> prices = [7,1,5,3,6,4]
|
||||
<strong>输出:</strong> 7
|
||||
<strong>解释:</strong> 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
|
||||
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> prices = [1,2,3,4,5]
|
||||
<strong>输出:</strong> 4
|
||||
<strong>解释:</strong> 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
|
||||
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> prices = [7,6,4,3,1]
|
||||
<strong>输出:</strong> 0
|
||||
<strong>解释:</strong> 在这种情况下, 没有交易完成, 所以最大利润为 0。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>给定一个数组，它的第<em> </em><code>i</code> 个元素是一支给定的股票在第 <code>i</code><em> </em>天的价格。</p>
|
||||
|
||||
<p>设计一个算法来计算你所能获取的最大利润。你最多可以完成 <strong>两笔 </strong>交易。</p>
|
||||
|
||||
<p><strong>注意：</strong>你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [3,3,5,0,0,3,1,4]
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
|
||||
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [1,2,3,4,5]
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
|
||||
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
|
||||
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [7,6,4,3,1]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>在这个情况下, 没有交易完成, 所以最大利润为 0。</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [1]
|
||||
<strong>输出：</strong>0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= prices[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>给定一个整数数组 <code>prices</code> ，它的第<em> </em><code>i</code> 个元素 <code>prices[i]</code> 是一支给定的股票在第 <code>i</code><em> </em>天的价格。</p>
|
||||
|
||||
<p>设计一个算法来计算你所能获取的最大利润。你最多可以完成 <strong>k</strong> 笔交易。</p>
|
||||
|
||||
<p><strong>注意：</strong>你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 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>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>k = 2, prices = [3,2,6,5,0,3]
|
||||
<strong>输出：</strong>7
|
||||
<strong>解释：</strong>在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
|
||||
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。</pre>
|
||||
|
||||
<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>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>给定一个数组 <code>prices</code> ，它的第 <code>i</code> 个元素 <code>prices[i]</code> 表示一支给定股票第 <code>i</code> 天的价格。</p>
|
||||
|
||||
<p>你只能选择 <strong>某一天</strong> 买入这只股票，并选择在 <strong>未来的某一个不同的日子</strong> 卖出该股票。设计一个算法来计算你所能获取的最大利润。</p>
|
||||
|
||||
<p>返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 <code>0</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>[7,1,5,3,6,4]
|
||||
<strong>输出：</strong>5
|
||||
<strong>解释：</strong>在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
|
||||
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>prices = [7,6,4,3,1]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>在这种情况下, 没有交易完成, 所以最大利润为 0。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prices.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= prices[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>给定一个二叉搜索树的根节点 <code>root</code> ，和一个整数 <code>k</code> ，请你设计一个算法查找其中第 <code>k</code><strong> </strong>个最小元素（从 1 开始计数）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg" style="width: 212px; height: 301px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,1,4,null,2], k = 1
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg" style="width: 382px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [5,3,6,2,4,null,null,1], k = 3
|
||||
<strong>输出：</strong>3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中的节点数为 <code>n</code> 。</li>
|
||||
<li><code>1 <= k <= n <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= Node.val <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 <code>k</code> 小的值，你将如何优化算法？</p>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。</p>
|
||||
|
||||
<p><a href="https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin" target="_blank">百度百科</a>中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（<strong>一个节点也可以是它自己的祖先</strong>）。”</p>
|
||||
|
||||
<p>例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/binarysearchtree_improved.png" style="height: 190px; width: 200px;"></p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
|
||||
<strong>输出:</strong> 6
|
||||
<strong>解释: </strong>节点 <code>2 </code>和节点 <code>8 </code>的最近公共祖先是 <code>6。</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
|
||||
<strong>输出:</strong> 2
|
||||
<strong>解释: </strong>节点 <code>2</code> 和节点 <code>4</code> 的最近公共祖先是 <code>2</code>, 因为根据定义最近公共祖先节点可以为节点本身。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>说明:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>所有节点的值都是唯一的。</li>
|
||||
<li>p、q 为不同节点且均存在于给定的二叉搜索树中。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,56 @@
|
||||
实现一个二叉搜索树迭代器类<code>BSTIterator</code> ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<ul>
|
||||
<li><code>BSTIterator(TreeNode root)</code> 初始化 <code>BSTIterator</code> 类的一个对象。BST 的根节点 <code>root</code> 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。</li>
|
||||
<li><code>boolean hasNext()</code> 如果向指针右侧遍历存在数字，则返回 <code>true</code> ；否则返回 <code>false</code> 。</li>
|
||||
<li><code>int next()</code>将指针向右移动，然后返回指针处的数字。</li>
|
||||
</ul>
|
||||
|
||||
<p>注意，指针初始化为一个不存在于 BST 中的数字，所以对 <code>next()</code> 的首次调用将返回 BST 中的最小元素。</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<p>你可以假设 <code>next()</code> 调用总是有效的，也就是说，当调用 <code>next()</code> 时，BST 的中序遍历中至少存在一个下一个数字。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png" style="width: 189px; height: 178px;" />
|
||||
<pre>
|
||||
<strong>输入</strong>
|
||||
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
|
||||
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
|
||||
<strong>输出</strong>
|
||||
[null, 3, 7, true, 9, true, 15, true, 20, false]
|
||||
|
||||
<strong>解释</strong>
|
||||
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
|
||||
bSTIterator.next(); // 返回 3
|
||||
bSTIterator.next(); // 返回 7
|
||||
bSTIterator.hasNext(); // 返回 True
|
||||
bSTIterator.next(); // 返回 9
|
||||
bSTIterator.hasNext(); // 返回 True
|
||||
bSTIterator.next(); // 返回 15
|
||||
bSTIterator.hasNext(); // 返回 True
|
||||
bSTIterator.next(); // 返回 20
|
||||
bSTIterator.hasNext(); // 返回 False
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数目在范围 <code>[1, 10<sup>5</sup>]</code> 内</li>
|
||||
<li><code>0 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li>最多调用 <code>10<sup>5</sup></code> 次 <code>hasNext</code> 和 <code>next</code> 操作</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>你可以设计一个满足下述条件的解决方案吗？<code>next()</code> 和 <code>hasNext()</code> 操作均摊时间复杂度为 <code>O(1)</code> ，并使用 <code>O(h)</code> 内存。其中 <code>h</code> 是树的高度。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p><strong>路径</strong> 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 <strong>至多出现一次</strong> 。该路径<strong> 至少包含一个 </strong>节点，且不一定经过根节点。</p>
|
||||
|
||||
<p><strong>路径和</strong> 是路径中各节点值的总和。</p>
|
||||
|
||||
<p>给你一个二叉树的根节点 <code>root</code> ，返回其 <strong>最大路径和</strong> 。</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>
|
||||
|
||||
<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
|
||||
</pre>
|
||||
|
||||
<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>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>给你二叉树的根结点 <code>root</code> ，请你将它展开为一个单链表：</p>
|
||||
|
||||
<ul>
|
||||
<li>展开后的单链表应该同样使用 <code>TreeNode</code> ，其中 <code>right</code> 子指针指向链表中下一个结点，而左子指针始终为 <code>null</code> 。</li>
|
||||
<li>展开后的单链表应该与二叉树 <a href="https://baike.baidu.com/item/%E5%85%88%E5%BA%8F%E9%81%8D%E5%8E%86/6442839?fr=aladdin" target="_blank"><strong>先序遍历</strong></a> 顺序相同。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg" style="width: 500px; height: 226px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,5,3,4,null,6]
|
||||
<strong>输出：</strong>[1,null,2,null,3,null,4,null,5,null,6]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [0]
|
||||
<strong>输出：</strong>[0]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中结点数在范围 <code>[0, 2000]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你可以使用原地算法（<code>O(1)</code> 额外空间）展开这棵树吗？</p>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>给定一个二叉树的根节点 <code>root</code> ，返回 <em>它的 <strong>中序</strong> 遍历</em> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="height: 200px; width: 125px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2,3]
|
||||
<strong>输出：</strong>[1,3,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[0, 100]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶:</strong> 递归算法很简单，你可以通过迭代算法完成吗？</p>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>给你二叉树的根节点 <code>root</code> ，返回它节点值的 <strong>前序</strong><em> </em>遍历。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 202px; height: 324px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2,3]
|
||||
<strong>输出：</strong>[1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg" style="width: 202px; height: 202px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 5：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg" style="width: 202px; height: 202px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[0, 100]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>递归算法很简单，你可以通过迭代算法完成吗？</p>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>给定一个二叉树的 <strong>根节点</strong> <code>root</code>，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<p><img src="https://assets.leetcode.com/uploads/2021/02/14/tree.jpg" style="width: 270px; " /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,2,3,null,5,null,4]
|
||||
<strong>输出:</strong> [1,3,4]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> [1,null,3]
|
||||
<strong>输出:</strong> [1,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> []
|
||||
<strong>输出:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>二叉树的节点个数的范围是 <code>[0,100]</code></li>
|
||||
<li><meta charset="UTF-8" /><code>-100 <= Node.val <= 100</code> </li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>给你一棵二叉树的根节点 <code>root</code> ，返回其节点值的 <strong>后序遍历 </strong>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/pre1.jpg" style="width: 127px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2,3]
|
||||
<strong>输出：</strong>[3,2,1]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数目在范围 <code>[0, 100]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>递归算法很简单，你可以通过迭代算法完成吗？</p>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>给你二叉树的根节点 <code>root</code> ，返回其节点值 <strong>自底向上的层序遍历</strong> 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,9,20,null,null,15,7]
|
||||
<strong>输出：</strong>[[15,7],[9,20],[3]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[0, 2000]</code> 内</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>给你二叉树的根节点 <code>root</code> ，返回其节点值的 <strong>层序遍历</strong> 。 （即逐层地，从左到右访问所有节点）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,9,20,null,null,15,7]
|
||||
<strong>输出：</strong>[[3],[9,20],[15,7]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[0, 2000]</code> 内</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。</p>
|
||||
|
||||
<p>请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。</p>
|
||||
|
||||
<p><strong>提示: </strong>输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 <a href="/faq/#binary-tree">LeetCode 序列化二叉树的格式</a>。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/serdeser.jpg" style="width: 442px; height: 324px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,null,null,4,5]
|
||||
<strong>输出：</strong>[1,2,3,null,null,4,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中结点数在范围 <code>[0, 10<sup>4</sup>]</code> 内</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
27
算法题（国内版）/problem (Chinese)/二叉树的所有路径 [binary-tree-paths].html
Normal file
27
算法题（国内版）/problem (Chinese)/二叉树的所有路径 [binary-tree-paths].html
Normal file
@@ -0,0 +1,27 @@
|
||||
<p>给你一个二叉树的根节点 <code>root</code> ，按 <strong>任意顺序</strong> ，返回所有从根节点到叶子节点的路径。</p>
|
||||
|
||||
<p><strong>叶子节点</strong> 是指没有子节点的节点。</p>
|
||||
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/12/paths-tree.jpg" style="width: 207px; height: 293px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2,3,null,5]
|
||||
<strong>输出：</strong>["1->2->5","1->3"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>["1"]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数目在范围 <code>[1, 100]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,16 @@
|
||||
<p>给定一个二叉树，找出其最大深度。</p>
|
||||
|
||||
<p>二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。</p>
|
||||
|
||||
<p><strong>说明:</strong> 叶子节点是指没有子节点的节点。</p>
|
||||
|
||||
<p><strong>示例：</strong><br>
|
||||
给定二叉树 <code>[3,9,20,null,null,15,7]</code>，</p>
|
||||
|
||||
<pre> 3
|
||||
/ \
|
||||
9 20
|
||||
/ \
|
||||
15 7</pre>
|
||||
|
||||
<p>返回它的最大深度 3 。</p>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>给定一个二叉树，找出其最小深度。</p>
|
||||
|
||||
<p>最小深度是从根节点到最近叶子节点的最短路径上的节点数量。</p>
|
||||
|
||||
<p><strong>说明：</strong>叶子节点是指没有子节点的节点。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg" style="width: 432px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,9,20,null,null,15,7]
|
||||
<strong>输出：</strong>2
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [2,null,3,null,4,null,5,null,6]
|
||||
<strong>输出：</strong>5
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数的范围在 <code>[0, 10<sup>5</sup>]</code> 内</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。</p>
|
||||
|
||||
<p><a href="https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin" target="_blank">百度百科</a>中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（<strong>一个节点也可以是它自己的祖先</strong>）。”</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>节点 <code>5 </code>和节点 <code>1 </code>的最近公共祖先是节点 <code>3 。</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
|
||||
<strong>输出：</strong>5
|
||||
<strong>解释：</strong>节点 <code>5 </code>和节点 <code>4 </code>的最近公共祖先是节点 <code>5 。</code>因为根据定义最近公共祖先节点可以为节点本身。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2], p = 1, q = 2
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[2, 10<sup>5</sup>]</code> 内。</li>
|
||||
<li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li>
|
||||
<li>所有 <code>Node.val</code> <code>互不相同</code> 。</li>
|
||||
<li><code>p != q</code></li>
|
||||
<li><code>p</code> 和 <code>q</code> 均存在于给定的二叉树中。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>给你二叉树的根节点 <code>root</code> ，返回其节点值的 <strong>锯齿形层序遍历</strong> 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [3,9,20,null,null,15,7]
|
||||
<strong>输出：</strong>[[3],[20,9],[15,7]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[0, 2000]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p><big><small>给定一个二维矩阵 <code>matrix</code>，</small></big>以下类型的多个请求：</p>
|
||||
|
||||
<ul>
|
||||
<li><big><small>计算其子矩形范围内元素的总和，该子矩阵的 <strong>左上角</strong> 为 <code>(row1, col1)</code> ，<strong>右下角</strong> 为 <code>(row2, col2)</code> 。</small></big></li>
|
||||
</ul>
|
||||
|
||||
<p>实现 <code>NumMatrix</code> 类：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>NumMatrix(int[][] matrix)</code> 给定整数矩阵 <code>matrix</code> 进行初始化</li>
|
||||
<li><code>int sumRegion(int row1, int col1, int row2, int col2)</code> 返回<big><small> <strong>左上角</strong></small></big><big><small> <code>(row1, col1)</code> 、<strong>右下角</strong> <code>(row2, col2)</code></small></big> 所描述的子矩阵的元素 <strong>总和</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img src="https://pic.leetcode-cn.com/1626332422-wUpUHT-image.png" style="width: 200px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
["NumMatrix","sumRegion","sumRegion","sumRegion"]
|
||||
[[[[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]]
|
||||
<strong>输出:</strong>
|
||||
[null, 8, 11, 12]
|
||||
|
||||
<strong>解释:</strong>
|
||||
NumMatrix numMatrix = new NumMatrix([[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]);
|
||||
numMatrix.sumRegion(2, 1, 4, 3); // return 8 (红色矩形框的元素总和)
|
||||
numMatrix.sumRegion(1, 1, 2, 2); // return 11 (绿色矩形框的元素总和)
|
||||
numMatrix.sumRegion(1, 2, 2, 4); // return 12 (蓝色矩形框的元素总和)
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == matrix.length</code></li>
|
||||
<li><code>n == matrix[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 200</code><meta charset="UTF-8" /></li>
|
||||
<li><code>-10<sup>5</sup> <= matrix[i][j] <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= row1 <= row2 < m</code></li>
|
||||
<li><code>0 <= col1 <= col2 < n</code></li>
|
||||
<li><meta charset="UTF-8" />最多调用 <code>10<sup>4</sup></code> 次 <code>sumRegion</code> 方法</li>
|
||||
</ul>
|
||||
47
算法题（国内版）/problem (Chinese)/二进制手表 [binary-watch].html
Normal file
47
算法题（国内版）/problem (Chinese)/二进制手表 [binary-watch].html
Normal file
@@ -0,0 +1,47 @@
|
||||
<p>二进制手表顶部有 4 个 LED 代表<strong> 小时（0-11）</strong>，底部的 6 个 LED 代表<strong> 分钟（0-59）</strong>。每个 LED 代表一个 0 或 1，最低位在右侧。</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，下面的二进制手表读取 <code>"3:25"</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>给你一个整数 <code>turnedOn</code> ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以 <strong>按任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p>小时不会以零开头：</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，<code>"01:00"</code> 是无效的时间，正确的写法应该是 <code>"1:00"</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>分钟必须由两位数组成，可能会以零开头：</p>
|
||||
|
||||
<ul>
|
||||
<li>例如，<code>"10:2"</code> 是无效的时间，正确的写法应该是 <code>"10:02"</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>turnedOn = 1
|
||||
<strong>输出：</strong>["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>turnedOn = 9
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= turnedOn <= 10</code></li>
|
||||
</ul>
|
||||
25
算法题（国内版）/problem (Chinese)/二进制求和 [add-binary].html
Normal file
25
算法题（国内版）/problem (Chinese)/二进制求和 [add-binary].html
Normal file
@@ -0,0 +1,25 @@
|
||||
<p>给你两个二进制字符串，返回它们的和（用二进制表示）。</p>
|
||||
|
||||
<p>输入为 <strong>非空 </strong>字符串且只包含数字 <code>1</code> 和 <code>0</code>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> a = "11", b = "1"
|
||||
<strong>输出:</strong> "100"</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<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>
|
||||
</ul>
|
||||
49
算法题（国内版）/problem (Chinese)/交错字符串 [interleaving-string].html
Normal file
49
算法题（国内版）/problem (Chinese)/交错字符串 [interleaving-string].html
Normal file
@@ -0,0 +1,49 @@
|
||||
<p>给定三个字符串 <code>s1</code>、<code>s2</code>、<code>s3</code>，请你帮忙验证 <code>s3</code> 是否是由 <code>s1</code> 和 <code>s2</code><em> </em><strong>交错 </strong>组成的。</p>
|
||||
|
||||
<p>两个字符串 <code>s</code> 和 <code>t</code> <strong>交错</strong> 的定义与过程如下，其中每个字符串都会被分割成若干 <strong>非空</strong> 子字符串：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>s = s<sub>1</sub> + s<sub>2</sub> + ... + s<sub>n</sub></code></li>
|
||||
<li><code>t = t<sub>1</sub> + t<sub>2</sub> + ... + t<sub>m</sub></code></li>
|
||||
<li><code>|n - m| <= 1</code></li>
|
||||
<li><strong>交错</strong> 是 <code>s<sub>1</sub> + t<sub>1</sub> + s<sub>2</sub> + t<sub>2</sub> + s<sub>3</sub> + t<sub>3</sub> + ...</code> 或者 <code>t<sub>1</sub> + s<sub>1</sub> + t<sub>2</sub> + s<sub>2</sub> + t<sub>3</sub> + s<sub>3</sub> + ...</code></li>
|
||||
</ul>
|
||||
|
||||
<p><strong>注意：</strong><code>a + b</code> 意味着字符串 <code>a</code> 和 <code>b</code> 连接。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/02/interleave.jpg" />
|
||||
<pre>
|
||||
<strong>输入：</strong>s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s1 = "", s2 = "", s3 = ""
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= s1.length, s2.length <= 100</code></li>
|
||||
<li><code>0 <= s3.length <= 200</code></li>
|
||||
<li><code>s1</code>、<code>s2</code>、和 <code>s3</code> 都由小写英文字母组成</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>您能否仅使用 <code>O(s2.length)</code> 额外的内存空间来解决它?</p>
|
||||
@@ -0,0 +1,33 @@
|
||||
<p>某网站包含两个表，<code>Customers</code> 表和 <code>Orders</code> 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。</p>
|
||||
|
||||
<p><code>Customers</code> 表：</p>
|
||||
|
||||
<pre>+----+-------+
|
||||
| Id | Name |
|
||||
+----+-------+
|
||||
| 1 | Joe |
|
||||
| 2 | Henry |
|
||||
| 3 | Sam |
|
||||
| 4 | Max |
|
||||
+----+-------+
|
||||
</pre>
|
||||
|
||||
<p><code>Orders</code> 表：</p>
|
||||
|
||||
<pre>+----+------------+
|
||||
| Id | CustomerId |
|
||||
+----+------------+
|
||||
| 1 | 3 |
|
||||
| 2 | 1 |
|
||||
+----+------------+
|
||||
</pre>
|
||||
|
||||
<p>例如给定上述表格，你的查询应返回：</p>
|
||||
|
||||
<pre>+-----------+
|
||||
| Customers |
|
||||
+-----------+
|
||||
| Henry |
|
||||
| Max |
|
||||
+-----------+
|
||||
</pre>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>给定两个整数数组 <code>inorder</code> 和 <code>postorder</code> ，其中 <code>inorder</code> 是二叉树的中序遍历， <code>postorder</code> 是同一棵树的后序遍历，请你构造并返回这颗 <em>二叉树</em> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" />
|
||||
<pre>
|
||||
<b>输入：</b>inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
|
||||
<b>输出：</b>[3,9,20,null,null,15,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<b>输入：</b>inorder = [-1], postorder = [-1]
|
||||
<b>输出：</b>[-1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= inorder.length <= 3000</code></li>
|
||||
<li><code>postorder.length == inorder.length</code></li>
|
||||
<li><code>-3000 <= inorder[i], postorder[i] <= 3000</code></li>
|
||||
<li><code>inorder</code> 和 <code>postorder</code> 都由 <strong>不同</strong> 的值组成</li>
|
||||
<li><code>postorder</code> 中每一个值都在 <code>inorder</code> 中</li>
|
||||
<li><code>inorder</code> <strong>保证</strong>是树的中序遍历</li>
|
||||
<li><code>postorder</code> <strong>保证</strong>是树的后序遍历</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>给定两个整数数组 <code>preorder</code> 和 <code>inorder</code> ，其中 <code>preorder</code> 是二叉树的<strong>先序遍历</strong>， <code>inorder</code> 是同一棵树的<strong>中序遍历</strong>，请构造二叉树并返回其根节点。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" style="height: 302px; width: 277px;" />
|
||||
<pre>
|
||||
<strong>输入</strong><strong>:</strong> preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
|
||||
<strong>输出:</strong> [3,9,20,null,null,15,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> preorder = [-1], inorder = [-1]
|
||||
<strong>输出:</strong> [-1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= preorder.length <= 3000</code></li>
|
||||
<li><code>inorder.length == preorder.length</code></li>
|
||||
<li><code>-3000 <= preorder[i], inorder[i] <= 3000</code></li>
|
||||
<li><code>preorder</code> 和 <code>inorder</code> 均 <strong>无重复</strong> 元素</li>
|
||||
<li><code>inorder</code> 均出现在 <code>preorder</code></li>
|
||||
<li><code>preorder</code> <strong>保证</strong> 为二叉树的前序遍历序列</li>
|
||||
<li><code>inorder</code> <strong>保证</strong> 为二叉树的中序遍历序列</li>
|
||||
</ul>
|
||||
54
算法题（国内版）/problem (Chinese)/位1的个数 [number-of-1-bits].html
Normal file
54
算法题（国内版）/problem (Chinese)/位1的个数 [number-of-1-bits].html
Normal file
@@ -0,0 +1,54 @@
|
||||
<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><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>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>00000000000000000000000000001011
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong> 中，共有三位为 '1'。</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>00000000000000000000000010000000
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong> 中，共有一位为 '1'。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>11111111111111111111111111111101
|
||||
<strong>输出：</strong>31
|
||||
<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 中，共有 31 位为 '1'。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>输入必须是长度为 <code>32</code> 的 <strong>二进制串</strong> 。</li>
|
||||
</ul>
|
||||
|
||||
<ul>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶</strong>：</p>
|
||||
|
||||
<ul>
|
||||
<li>如果多次调用这个函数，你将如何优化你的算法？</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>给你一个二维整数数组 <code>envelopes</code> ，其中 <code>envelopes[i] = [w<sub>i</sub>, h<sub>i</sub>]</code> ，表示第 <code>i</code> 个信封的宽度和高度。</p>
|
||||
|
||||
<p>当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。</p>
|
||||
|
||||
<p>请计算 <strong>最多能有多少个</strong> 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。</p>
|
||||
|
||||
<p><strong>注意</strong>：不允许旋转信封。</p>
|
||||
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>envelopes = [[5,4],[6,4],[6,7],[2,3]]
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>最多信封的个数为 <code>3, 组合为: </code>[2,3] => [5,4] => [6,7]。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>envelopes = [[1,1],[1,1],[1,1]]
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= envelopes.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>envelopes[i].length == 2</code></li>
|
||||
<li><code>1 <= w<sub>i</sub>, h<sub>i</sub> <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
69
算法题（国内版）/problem (Chinese)/克隆图 [clone-graph].html
Normal file
69
算法题（国内版）/problem (Chinese)/克隆图 [clone-graph].html
Normal file
@@ -0,0 +1,69 @@
|
||||
<p>给你无向 <strong><a href="https://baike.baidu.com/item/连通图/6460995?fr=aladdin" target="_blank">连通</a> </strong>图中一个节点的引用，请你返回该图的 <a href="https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin" target="_blank"><strong>深拷贝</strong></a>（克隆）。</p>
|
||||
|
||||
<p>图中的每个节点都包含它的值 <code>val</code>（<code>int</code>） 和其邻居的列表（<code>list[Node]</code>）。</p>
|
||||
|
||||
<pre>class Node {
|
||||
public int val;
|
||||
public List<Node> neighbors;
|
||||
}</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>测试用例格式：</strong></p>
|
||||
|
||||
<p>简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（<code>val = 1</code>），第二个节点值为 2（<code>val = 2</code>），以此类推。该图在测试用例中使用邻接列表表示。</p>
|
||||
|
||||
<p><strong>邻接列表</strong> 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。</p>
|
||||
|
||||
<p>给定节点将始终是图中的第一个节点（值为 1）。你必须将 <strong>给定节点的拷贝 </strong>作为对克隆图的引用返回。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/133_clone_graph_question.png" style="height: 500px; width: 500px;"></p>
|
||||
|
||||
<pre><strong>输入：</strong>adjList = [[2,4],[1,3],[2,4],[1,3]]
|
||||
<strong>输出：</strong>[[2,4],[1,3],[2,4],[1,3]]
|
||||
<strong>解释：
|
||||
</strong>图中有 4 个节点。
|
||||
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
|
||||
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
|
||||
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
|
||||
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph.png" style="height: 148px; width: 163px;"></p>
|
||||
|
||||
<pre><strong>输入：</strong>adjList = [[]]
|
||||
<strong>输出：</strong>[[]]
|
||||
<strong>解释：</strong>输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre><strong>输入：</strong>adjList = []
|
||||
<strong>输出：</strong>[]
|
||||
<strong>解释：</strong>这个图是空的，它不含任何节点。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph-1.png" style="height: 133px; width: 272px;"></p>
|
||||
|
||||
<pre><strong>输入：</strong>adjList = [[2],[1]]
|
||||
<strong>输出：</strong>[[2],[1]]</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ol>
|
||||
<li>节点数不超过 100 。</li>
|
||||
<li>每个节点值 <code>Node.val</code> 都是唯一的，<code>1 <= Node.val <= 100</code>。</li>
|
||||
<li>无向图是一个<a href="https://baike.baidu.com/item/简单图/1680528?fr=aladdin" target="_blank">简单图</a>，这意味着图中没有重复的边，也没有自环。</li>
|
||||
<li>由于图是无向的，如果节点 <em>p</em> 是节点 <em>q</em> 的邻居，那么节点 <em>q</em> 也必须是节点 <em>p</em> 的邻居。</li>
|
||||
<li>图是连通图，你可以从给定节点访问到所有节点。</li>
|
||||
</ol>
|
||||
29
算法题（国内版）/problem (Chinese)/全排列 II [permutations-ii].html
Normal file
29
算法题（国内版）/problem (Chinese)/全排列 II [permutations-ii].html
Normal file
@@ -0,0 +1,29 @@
|
||||
<p>给定一个可包含重复数字的序列 <code>nums</code> ，<em><strong>按任意顺序</strong></em> 返回所有不重复的全排列。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,1,2]
|
||||
<strong>输出：</strong>
|
||||
[[1,1,2],
|
||||
[1,2,1],
|
||||
[2,1,1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3]
|
||||
<strong>输出：</strong>[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 8</code></li>
|
||||
<li><code>-10 <= nums[i] <= 10</code></li>
|
||||
</ul>
|
||||
34
算法题（国内版）/problem (Chinese)/全排列 [permutations].html
Normal file
34
算法题（国内版）/problem (Chinese)/全排列 [permutations].html
Normal file
@@ -0,0 +1,34 @@
|
||||
<p>给定一个不含重复数字的数组 <code>nums</code> ，返回其 <em>所有可能的全排列</em> 。你可以 <strong>按任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3]
|
||||
<strong>输出：</strong>[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0,1]
|
||||
<strong>输出：</strong>[[0,1],[1,0]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1]
|
||||
<strong>输出：</strong>[[1]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 6</code></li>
|
||||
<li><code>-10 <= nums[i] <= 10</code></li>
|
||||
<li><code>nums</code> 中的所有整数 <strong>互不相同</strong></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>给你一个字符串 <code>s</code>，请你将 <code>s</code> 分割成一些子串，使每个子串都是回文。</p>
|
||||
|
||||
<p>返回符合要求的 <strong>最少分割次数</strong> 。</p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "aab"
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>只需一次分割就可将 <em>s </em>分割成 ["aa","b"] 这样两个回文子串。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "a"
|
||||
<strong>输出：</strong>0
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "ab"
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 2000</code></li>
|
||||
<li><code>s</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>给你一个字符串 <code>s</code>，请你将<em> </em><code>s</code><em> </em>分割成一些子串，使每个子串都是 <strong>回文串</strong> 。返回 <code>s</code> 所有可能的分割方案。</p>
|
||||
|
||||
<p><strong>回文串</strong> 是正着读和反着读都一样的字符串。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "aab"
|
||||
<strong>输出：</strong>[["a","a","b"],["aa","b"]]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "a"
|
||||
<strong>输出：</strong>[["a"]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 16</code></li>
|
||||
<li><code>s</code> 仅由小写英文字母组成</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>给定一个非负整数数组 <code>nums</code> 和一个整数 <code>m</code> ，你需要将这个数组分成 <code>m</code><em> </em>个非空的连续子数组。</p>
|
||||
|
||||
<p>设计一个算法使得这 <code>m</code><em> </em>个子数组各自和的最大值最小。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [7,2,5,10,8], m = 2
|
||||
<strong>输出：</strong>18
|
||||
<strong>解释：</strong>
|
||||
一共有四种方法将 nums 分割为 2 个子数组。
|
||||
其中最好的方式是将其分为 [7,2,5] 和 [10,8] 。
|
||||
因为此时这两个子数组各自的和的最大值为18，在所有情况中最小。</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,2,3,4,5], m = 2
|
||||
<strong>输出：</strong>9
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,4,4], m = 3
|
||||
<strong>输出：</strong>4
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>1 <= m <= min(50, nums.length)</code></li>
|
||||
</ul>
|
||||
38
算法题（国内版）/problem (Chinese)/分发糖果 [candy].html
Normal file
38
算法题（国内版）/problem (Chinese)/分发糖果 [candy].html
Normal file
@@ -0,0 +1,38 @@
|
||||
<p><code>n</code> 个孩子站成一排。给你一个整数数组 <code>ratings</code> 表示每个孩子的评分。</p>
|
||||
|
||||
<p>你需要按照以下要求，给这些孩子分发糖果：</p>
|
||||
|
||||
<ul>
|
||||
<li>每个孩子至少分配到 <code>1</code> 个糖果。</li>
|
||||
<li>相邻两个孩子评分更高的孩子会获得更多的糖果。</li>
|
||||
</ul>
|
||||
|
||||
<p>请你给每个孩子分发糖果，计算并返回需要准备的 <strong>最少糖果数目</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>ratings = [1,0,2]
|
||||
<strong>输出：</strong>5
|
||||
<strong>解释：</strong>你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>ratings = [1,2,2]
|
||||
<strong>输出：</strong>4
|
||||
<strong>解释：</strong>你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
|
||||
第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == ratings.length</code></li>
|
||||
<li><code>1 <= n <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= ratings[i] <= 2 * 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>给定两个整数，分别表示分数的分子 <code>numerator</code> 和分母 <code>denominator</code>，以 <strong>字符串形式返回小数</strong> 。</p>
|
||||
|
||||
<p>如果小数部分为循环小数，则将循环的部分括在括号内。</p>
|
||||
|
||||
<p>如果存在多个答案，只需返回 <strong>任意一个</strong> 。</p>
|
||||
|
||||
<p>对于所有给定的输入，<strong>保证</strong> 答案字符串的长度小于 <code>10<sup>4</sup></code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numerator = 1, denominator = 2
|
||||
<strong>输出：</strong>"0.5"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numerator = 2, denominator = 1
|
||||
<strong>输出：</strong>"2"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>numerator = 4, denominator = 333
|
||||
<strong>输出：</strong>"0.(012)"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= numerator, denominator <= 2<sup>31</sup> - 1</code></li>
|
||||
<li><code>denominator != 0</code></li>
|
||||
</ul>
|
||||
55
算法题（国内版）/problem (Chinese)/分数排名 [rank-scores].html
Normal file
55
算法题（国内版）/problem (Chinese)/分数排名 [rank-scores].html
Normal file
@@ -0,0 +1,55 @@
|
||||
<p>表: <code>Scores</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| id | int |
|
||||
| score | decimal |
|
||||
+-------------+---------+
|
||||
Id是该表的主键。
|
||||
该表的每一行都包含了一场比赛的分数。Score是一个有两位小数点的浮点值。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>编写 SQL 查询对分数进行排序。排名按以下规则计算:</p>
|
||||
|
||||
<ul>
|
||||
<li>分数应按从高到低排列。</li>
|
||||
<li>如果两个分数相等，那么两个分数的排名应该相同。</li>
|
||||
<li>在排名相同的分数后，排名数应该是下一个连续的整数。换句话说，排名之间不应该有空缺的数字。</li>
|
||||
</ul>
|
||||
|
||||
<p>按 <code>score</code> 降序返回结果表。</p>
|
||||
|
||||
<p>查询结果格式如下所示。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
Scores 表:
|
||||
+----+-------+
|
||||
| id | score |
|
||||
+----+-------+
|
||||
| 1 | 3.50 |
|
||||
| 2 | 3.65 |
|
||||
| 3 | 4.00 |
|
||||
| 4 | 3.85 |
|
||||
| 5 | 4.00 |
|
||||
| 6 | 3.65 |
|
||||
+----+-------+
|
||||
<strong>输出:</strong>
|
||||
+-------+------+
|
||||
| score | rank |
|
||||
+-------+------+
|
||||
| 4.00 | 1 |
|
||||
| 4.00 | 1 |
|
||||
| 3.85 | 2 |
|
||||
| 3.65 | 3 |
|
||||
| 3.65 | 3 |
|
||||
| 3.50 | 4 |
|
||||
+-------+------+</pre>
|
||||
29
算法题（国内版）/problem (Chinese)/分隔链表 [partition-list].html
Normal file
29
算法题（国内版）/problem (Chinese)/分隔链表 [partition-list].html
Normal file
@@ -0,0 +1,29 @@
|
||||
<p>给你一个链表的头节点 <code>head</code> 和一个特定值<em> </em><code>x</code> ，请你对链表进行分隔，使得所有 <strong>小于</strong> <code>x</code> 的节点都出现在 <strong>大于或等于</strong> <code>x</code> 的节点之前。</p>
|
||||
|
||||
<p>你应当 <strong>保留</strong> 两个分区中每个节点的初始相对位置。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/partition.jpg" style="width: 662px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,4,3,2,5,2], x = 3
|
||||
<strong>输出</strong>：[1,2,2,4,3,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [2,1], x = 2
|
||||
<strong>输出</strong>：[1,2]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>链表中节点的数目在范围 <code>[0, 200]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li><code>-200 <= x <= 200</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>给定一个已排序的链表的头 <code>head</code> ， <em>删除原始链表中所有重复数字的节点，只留下不同的数字</em> 。返回 <em>已排序的链表</em> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg" style="height: 142px; width: 500px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,2,3,3,4,4,5]
|
||||
<strong>输出：</strong>[1,2,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg" style="height: 164px; width: 400px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,1,1,2,3]
|
||||
<strong>输出：</strong>[2,3]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>链表中节点数目在范围 <code>[0, 300]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li>题目数据保证链表已经按升序 <strong>排列</strong></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>给定一个已排序的链表的头<meta charset="UTF-8" /> <code>head</code> ， <em>删除所有重复的元素，使每个元素只出现一次</em> 。返回 <em>已排序的链表</em> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/list1.jpg" style="height: 160px; width: 200px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,1,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/list2.jpg" style="height: 123px; width: 300px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,1,2,3,3]
|
||||
<strong>输出：</strong>[1,2,3]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>链表中节点数目在范围 <code>[0, 300]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li>题目数据保证链表已经按升序 <strong>排列</strong></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>给你一个由若干括号和字母组成的字符串 <code>s</code> ，删除最小数量的无效括号，使得输入的字符串有效。</p>
|
||||
|
||||
<p>返回所有可能的结果。答案可以按 <strong>任意顺序</strong> 返回。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "()())()"
|
||||
<strong>输出：</strong>["(())()","()()()"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "(a)())()"
|
||||
<strong>输出：</strong>["(a())()","(a)()()"]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = ")("
|
||||
<strong>输出：</strong>[""]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 25</code></li>
|
||||
<li><code>s</code> 由小写英文字母以及括号 <code>'('</code> 和 <code>')'</code> 组成</li>
|
||||
<li><code>s</code> 中至多含 <code>20</code> 个括号</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>给你一个有序数组 <code>nums</code> ，请你<strong><a href="http://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank"> 原地</a></strong> 删除重复出现的元素，使每个元素 <strong>最多出现两次</strong> ，返回删除后数组的新长度。</p>
|
||||
|
||||
<p>不要使用额外的数组空间，你必须在 <strong><a href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank">原地 </a>修改输入数组 </strong>并在使用 O(1) 额外空间的条件下完成。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>说明：</strong></p>
|
||||
|
||||
<p>为什么返回数值是整数，但输出的答案是数组呢？</p>
|
||||
|
||||
<p>请注意，输入数组是以<strong>「引用」</strong>方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。</p>
|
||||
|
||||
<p>你可以想象内部操作如下:</p>
|
||||
|
||||
<pre>
|
||||
// <strong>nums</strong> 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
|
||||
int len = removeDuplicates(nums);
|
||||
|
||||
// 在函数里修改输入数组对于调用者是可见的。
|
||||
// 根据你的函数返回的长度, 它会打印出数组中<strong> 该长度范围内</strong> 的所有元素。
|
||||
for (int i = 0; i < len; i++) {
|
||||
print(nums[i]);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,1,1,2,2,3]
|
||||
<strong>输出：</strong>5, nums = [1,1,2,2,3]
|
||||
<strong>解释：</strong>函数应返回新长度 length = <strong><code>5</code></strong>, 并且原数组的前五个元素被修改为 <strong><code>1, 1, 2, 2,</code></strong> <strong>3 </strong>。 不需要考虑数组中超出新长度后面的元素。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0,0,1,1,1,1,2,3,3]
|
||||
<strong>输出：</strong>7, nums = [0,0,1,1,2,3,3]
|
||||
<strong>解释：</strong>函数应返回新长度 length = <strong><code>7</code></strong>, 并且原数组的前五个元素被修改为 <strong><code>0</code></strong>, <strong>0</strong>, <strong>1</strong>, <strong>1</strong>, <strong>2</strong>, <strong>3</strong>, <strong>3 。</strong> 不需要考虑数组中超出新长度后面的元素。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
|
||||
<li><code>nums</code> 已按升序排列</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>给你一个 <strong>升序排列</strong> 的数组 <code>nums</code> ，请你<strong><a href="http://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank"> 原地</a></strong> 删除重复出现的元素，使每个元素 <strong>只出现一次</strong> ，返回删除后数组的新长度。元素的 <strong>相对顺序</strong> 应该保持 <strong>一致</strong> 。</p>
|
||||
|
||||
<p>由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 <code>k</code> 个元素，那么 <code>nums</code> 的前 <code>k</code> 个元素应该保存最终结果。</p>
|
||||
|
||||
<p>将最终结果插入 <code>nums</code> 的前 <code>k</code> 个位置后返回 <code>k</code> 。</p>
|
||||
|
||||
<p>不要使用额外的空间，你必须在 <strong><a href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank">原地 </a>修改输入数组 </strong>并在使用 O(1) 额外空间的条件下完成。</p>
|
||||
|
||||
<p><strong>判题标准:</strong></p>
|
||||
|
||||
<p>系统会用下面的代码来测试你的题解:</p>
|
||||
|
||||
<pre>
|
||||
int[] nums = [...]; // 输入数组
|
||||
int[] expectedNums = [...]; // 长度正确的期望答案
|
||||
|
||||
int k = removeDuplicates(nums); // 调用
|
||||
|
||||
assert k == expectedNums.length;
|
||||
for (int i = 0; i < k; i++) {
|
||||
assert nums[i] == expectedNums[i];
|
||||
}</pre>
|
||||
|
||||
<p>如果所有断言都通过，那么您的题解将被 <strong>通过</strong>。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,1,2]
|
||||
<strong>输出：</strong>2, nums = [1,2,_]
|
||||
<strong>解释：</strong>函数应该返回新的长度 <strong><code>2</code></strong> ，并且原数组 <em>nums </em>的前两个元素被修改为 <strong><code>1</code></strong>, <strong><code>2 </code></strong><code>。</code>不需要考虑数组中超出新长度后面的元素。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0,0,1,1,1,2,2,3,3,4]
|
||||
<strong>输出：</strong>5, nums = [0,1,2,3,4]
|
||||
<strong>解释：</strong>函数应该返回新的长度 <strong><code>5</code></strong> ， 并且原数组 <em>nums </em>的前五个元素被修改为 <strong><code>0</code></strong>, <strong><code>1</code></strong>, <strong><code>2</code></strong>, <strong><code>3</code></strong>, <strong><code>4</code></strong> 。不需要考虑数组中超出新长度后面的元素。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= nums.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
|
||||
<li><code>nums</code> 已按 <strong>升序</strong> 排列</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>表: <code>Person</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| id | int |
|
||||
| email | varchar |
|
||||
+-------------+---------+
|
||||
id是该表的主键列。
|
||||
该表的每一行包含一封电子邮件。电子邮件将不包含大写字母。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>编写一个SQL查询来 <strong>删除</strong> 所有重复的电子邮件，只保留一个id最小的唯一电子邮件。</p>
|
||||
|
||||
<p>以 <strong>任意顺序</strong> 返回结果表。</p>
|
||||
|
||||
<p>查询结果格式如下所示。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>
|
||||
Person 表:
|
||||
+----+------------------+
|
||||
| id | email |
|
||||
+----+------------------+
|
||||
| 1 | john@example.com |
|
||||
| 2 | bob@example.com |
|
||||
| 3 | john@example.com |
|
||||
+----+------------------+
|
||||
<strong>输出:</strong>
|
||||
+----+------------------+
|
||||
| id | email |
|
||||
+----+------------------+
|
||||
| 1 | john@example.com |
|
||||
| 2 | bob@example.com |
|
||||
+----+------------------+
|
||||
<strong>解释:</strong> john@example.com重复两次。我们保留最小的Id = 1。</pre>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>请编写一个函数，用于 <strong>删除单链表中某个特定节点</strong> 。在设计函数时需要注意，你无法访问链表的头节点 <code>head</code> ，只能直接访问 <strong>要被删除的节点</strong> 。</p>
|
||||
|
||||
<p>题目数据保证需要删除的节点 <strong>不是末尾节点</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node1.jpg" style="height: 215px; width: 300px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [4,5,1,9], node = 5
|
||||
<strong>输出：</strong>[4,1,9]
|
||||
<strong>解释：</strong>指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node2.jpg" style="height: 236px; width: 300px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [4,5,1,9], node = 1
|
||||
<strong>输出：</strong>[4,5,9]
|
||||
<strong>解释：</strong>指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>链表中节点的数目范围是 <code>[2, 1000]</code></li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
<li>链表中每个节点的值都是 <strong>唯一</strong> 的</li>
|
||||
<li>需要删除的节点 <code>node</code> 是 <strong>链表中的节点</strong> ，且 <strong>不是末尾节点</strong></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>给你一个链表，删除链表的倒数第 <code>n</code><em> </em>个结点，并且返回链表的头结点。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/remove_ex1.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,2,3,4,5], n = 2
|
||||
<strong>输出：</strong>[1,2,3,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1], n = 1
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>head = [1,2], n = 1
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>链表中结点的数目为 <code>sz</code></li>
|
||||
<li><code>1 <= sz <= 30</code></li>
|
||||
<li><code>0 <= Node.val <= 100</code></li>
|
||||
<li><code>1 <= n <= sz</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你能尝试使用一趟扫描实现吗？</p>
|
||||
37
算法题（国内版）/problem (Chinese)/判断子序列 [is-subsequence].html
Normal file
37
算法题（国内版）/problem (Chinese)/判断子序列 [is-subsequence].html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>给定字符串 <strong>s</strong> 和 <strong>t</strong> ，判断 <strong>s</strong> 是否为 <strong>t</strong> 的子序列。</p>
|
||||
|
||||
<p>字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，<code>"ace"</code>是<code>"abcde"</code>的一个子序列，而<code>"aec"</code>不是）。</p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<p>如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？</p>
|
||||
|
||||
<p><strong>致谢：</strong></p>
|
||||
|
||||
<p>特别感谢<strong> </strong><a href="https://leetcode.com/pbrother/">@pbrother </a>添加此问题并且创建所有测试用例。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "abc", t = "ahbgdc"
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>s = "axc", t = "ahbgdc"
|
||||
<strong>输出：</strong>false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= s.length <= 100</code></li>
|
||||
<li><code>0 <= t.length <= 10^4</code></li>
|
||||
<li>两个字符串都只由小写字符组成。</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>给你一个整数数组 <code>nums</code> 和一个整数 <code>k</code> ，请你返回其中出现频率前 <code>k</code> 高的元素。你可以按 <strong>任意顺序</strong> 返回答案。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>nums = [1,1,1,2,2,3], k = 2
|
||||
<strong>输出: </strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入: </strong>nums = [1], k = 1
|
||||
<strong>输出: </strong>[1]</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>k</code> 的取值范围是 <code>[1, 数组中不相同的元素的个数]</code></li>
|
||||
<li>题目数据保证答案唯一，换句话说，数组中前 <code>k</code> 个高频元素的集合是唯一的</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你所设计算法的时间复杂度 <strong>必须</strong> 优于 <code>O(n log n)</code> ，其中 <code>n</code><em> </em>是数组大小。</p>
|
||||
39
算法题（国内版）/problem (Chinese)/加一 [plus-one].html
Normal file
39
算法题（国内版）/problem (Chinese)/加一 [plus-one].html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>给定一个由 <strong>整数 </strong>组成的<strong> 非空</strong> 数组所表示的非负整数，在该数的基础上加一。</p>
|
||||
|
||||
<p>最高位数字存放在数组的首位， 数组中每个元素只存储<strong>单个</strong>数字。</p>
|
||||
|
||||
<p>你可以假设除了整数 0 之外，这个整数不会以零开头。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>digits = [1,2,3]
|
||||
<strong>输出：</strong>[1,2,4]
|
||||
<strong>解释：</strong>输入数组表示数字 123。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>digits = [4,3,2,1]
|
||||
<strong>输出：</strong>[4,3,2,2]
|
||||
<strong>解释：</strong>输入数组表示数字 4321。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>digits = [0]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= digits.length <= 100</code></li>
|
||||
<li><code>0 <= digits[i] <= 9</code></li>
|
||||
</ul>
|
||||
45
算法题（国内版）/problem (Chinese)/加油站 [gas-station].html
Normal file
45
算法题（国内版）/problem (Chinese)/加油站 [gas-station].html
Normal file
@@ -0,0 +1,45 @@
|
||||
<p>在一条环路上有 <code>n</code> 个加油站，其中第 <code>i</code> 个加油站有汽油 <code>gas[i]</code><em> </em>升。</p>
|
||||
|
||||
<p>你有一辆油箱容量无限的的汽车，从第<em> </em><code>i</code><em> </em>个加油站开往第<em> </em><code>i+1</code><em> </em>个加油站需要消耗汽油 <code>cost[i]</code><em> </em>升。你从其中的一个加油站出发，开始时油箱为空。</p>
|
||||
|
||||
<p>给定两个整数数组 <code>gas</code> 和 <code>cost</code> ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 <code>-1</code> 。如果存在解，则 <strong>保证</strong> 它是 <strong>唯一</strong> 的。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> gas = [1,2,3,4,5], cost = [3,4,5,1,2]
|
||||
<strong>输出:</strong> 3
|
||||
<strong>解释:
|
||||
</strong>从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
|
||||
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
|
||||
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
|
||||
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
|
||||
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
|
||||
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
|
||||
因此，3 可为起始索引。</pre>
|
||||
|
||||
<p><strong>示例 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> gas = [2,3,4], cost = [3,4,3]
|
||||
<strong>输出:</strong> -1
|
||||
<strong>解释:
|
||||
</strong>你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
|
||||
我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
|
||||
开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
|
||||
开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
|
||||
你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
|
||||
因此，无论怎样，你都不可能绕环路行驶一周。</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>gas.length == n</code></li>
|
||||
<li><code>cost.length == n</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= gas[i], cost[i] <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>给定一个整数数组 <code>nums</code>，处理以下类型的多个查询:</p>
|
||||
|
||||
<ol>
|
||||
<li>计算索引 <code>left</code> 和 <code>right</code> （包含 <code>left</code> 和 <code>right</code>）之间的 <code>nums</code> 元素的 <strong>和</strong> ，其中 <code>left <= right</code></li>
|
||||
</ol>
|
||||
|
||||
<p>实现 <code>NumArray</code> 类：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>NumArray(int[] nums)</code> 使用数组 <code>nums</code> 初始化对象</li>
|
||||
<li><code>int sumRange(int i, int j)</code> 返回数组 <code>nums</code> 中索引 <code>left</code> 和 <code>right</code> 之间的元素的 <strong>总和</strong> ，包含 <code>left</code> 和 <code>right</code> 两点（也就是 <code>nums[left] + nums[left + 1] + ... + nums[right]</code> )</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>
|
||||
["NumArray", "sumRange", "sumRange", "sumRange"]
|
||||
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
|
||||
<strong>输出：
|
||||
</strong>[null, 1, -1, -3]
|
||||
|
||||
<strong>解释：</strong>
|
||||
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
|
||||
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
|
||||
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
|
||||
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= i <= j < nums.length</code></li>
|
||||
<li>最多调用 <code>10<sup>4</sup></code> 次 <code>sumRange</code><strong> </strong>方法</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>给你一个数组 <code>nums</code> ，请你完成两类查询。</p>
|
||||
|
||||
<ol>
|
||||
<li>其中一类查询要求 <strong>更新</strong> 数组 <code>nums</code> 下标对应的值</li>
|
||||
<li>另一类查询要求返回数组 <code>nums</code> 中索引 <code>left</code> 和索引 <code>right</code> 之间（ <strong>包含 </strong>）的nums元素的 <strong>和</strong> ，其中 <code>left <= right</code></li>
|
||||
</ol>
|
||||
|
||||
<p>实现 <code>NumArray</code> 类：</p>
|
||||
|
||||
<ul>
|
||||
<li><code>NumArray(int[] nums)</code> 用整数数组 <code>nums</code> 初始化对象</li>
|
||||
<li><code>void update(int index, int val)</code> 将 <code>nums[index]</code> 的值 <strong>更新</strong> 为 <code>val</code></li>
|
||||
<li><code>int sumRange(int left, int right)</code> 返回数组 <code>nums</code> 中索引 <code>left</code> 和索引 <code>right</code> 之间（ <strong>包含 </strong>）的nums元素的 <strong>和</strong> （即，<code>nums[left] + nums[left + 1], ..., nums[right]</code>）</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入</strong>：
|
||||
["NumArray", "sumRange", "update", "sumRange"]
|
||||
[[[1, 3, 5]], [0, 2], [1, 2], [0, 2]]
|
||||
<strong>输出</strong>：
|
||||
[null, 9, null, 8]
|
||||
|
||||
<strong>解释</strong>：
|
||||
NumArray numArray = new NumArray([1, 3, 5]);
|
||||
numArray.sumRange(0, 2); // 返回 1 + 3 + 5 = 9
|
||||
numArray.update(1, 2); // nums = [1,2,5]
|
||||
numArray.sumRange(0, 2); // 返回 1 + 2 + 5 = 8
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>-100 <= nums[i] <= 100</code></li>
|
||||
<li><code>0 <= index < nums.length</code></li>
|
||||
<li><code>-100 <= val <= 100</code></li>
|
||||
<li><code>0 <= left <= right < nums.length</code></li>
|
||||
<li>调用 <code>pdate</code> 和 <code>sumRange</code> 方法次数不大于 <code>3 * 10<sup>4</sup></code> </li>
|
||||
</ul>
|
||||
30
算法题（国内版）/problem (Chinese)/区间和的个数 [count-of-range-sum].html
Normal file
30
算法题（国内版）/problem (Chinese)/区间和的个数 [count-of-range-sum].html
Normal file
@@ -0,0 +1,30 @@
|
||||
<p>给你一个整数数组 <code>nums</code> 以及两个整数 <code>lower</code> 和 <code>upper</code> 。求数组中，值位于范围 <code>[lower, upper]</code> （包含 <code>lower</code> 和 <code>upper</code>）之内的 <strong>区间和的个数</strong> 。</p>
|
||||
|
||||
<p><strong>区间和</strong> <code>S(i, j)</code> 表示在 <code>nums</code> 中，位置从 <code>i</code> 到 <code>j</code> 的元素之和，包含 <code>i</code> 和 <code>j</code> (<code>i</code> ≤ <code>j</code>)。</p>
|
||||
|
||||
<p> </p>
|
||||
<strong>示例 1：</strong>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [-2,5,-1], lower = -2, upper = 2
|
||||
<strong>输出：</strong>3
|
||||
<strong>解释：</strong>存在三个区间：[0,0]、[2,2] 和 [0,2] ，对应的区间和分别是：-2 、-1 、2 。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0], lower = 0, upper = 0
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code></li>
|
||||
<li><code>-10<sup>5</sup> <= lower <= upper <= 10<sup>5</sup></code></li>
|
||||
<li>题目数据保证答案是一个 <strong>32 位</strong> 的整数</li>
|
||||
</ul>
|
||||
41
算法题（国内版）/problem (Chinese)/单词拆分 II [word-break-ii].html
Normal file
41
算法题（国内版）/problem (Chinese)/单词拆分 II [word-break-ii].html
Normal file
@@ -0,0 +1,41 @@
|
||||
<p>给定一个字符串 <code>s</code> 和一个字符串字典<meta charset="UTF-8" /> <code>wordDict</code> ，在字符串<meta charset="UTF-8" /> <code>s</code> 中增加空格来构建一个句子，使得句子中所有的单词都在词典中。<strong>以任意顺序</strong> 返回所有这些可能的句子。</p>
|
||||
|
||||
<p><strong>注意：</strong>词典中的同一个单词可能在分段中被重复使用多次。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>s = "<code>catsanddog</code>", wordDict = <code>["cat","cats","and","sand","dog"]</code>
|
||||
<strong>输出:</strong><code>["cats and dog","cat sand dog"]</code>
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>s = "pineapplepenapple", wordDict = ["apple","pen","applepen","pine","pineapple"]
|
||||
<strong>输出:</strong>["pine apple pen apple","pineapple pen apple","pine applepen apple"]
|
||||
<strong>解释:</strong> 注意你可以重复使用字典中的单词。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong>s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
|
||||
<strong>输出:</strong>[]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<p><meta charset="UTF-8" /></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 20</code></li>
|
||||
<li><code>1 <= wordDict.length <= 1000</code></li>
|
||||
<li><code>1 <= wordDict[i].length <= 10</code></li>
|
||||
<li><code>s</code> 和 <code>wordDict[i]</code> 仅有小写英文字母组成</li>
|
||||
<li><code>wordDict</code> 中所有字符串都 <strong>不同</strong></li>
|
||||
</ul>
|
||||
41
算法题（国内版）/problem (Chinese)/单词拆分 [word-break].html
Normal file
41
算法题（国内版）/problem (Chinese)/单词拆分 [word-break].html
Normal file
@@ -0,0 +1,41 @@
|
||||
<p>给你一个字符串 <code>s</code> 和一个字符串列表 <code>wordDict</code> 作为字典。请你判断是否可以利用字典中出现的单词拼接出 <code>s</code> 。</p>
|
||||
|
||||
<p><strong>注意：</strong>不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> s = "leetcode", wordDict = ["leet", "code"]
|
||||
<strong>输出:</strong> true
|
||||
<strong>解释:</strong> 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> s = "applepenapple", wordDict = ["apple", "pen"]
|
||||
<strong>输出:</strong> true
|
||||
<strong>解释:</strong> 返回 true 因为 <code>"</code>applepenapple<code>"</code> 可以由 <code>"</code>apple" "pen" "apple<code>" 拼接成</code>。
|
||||
注意，你可以重复使用字典中的单词。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入:</strong> s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
|
||||
<strong>输出:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 300</code></li>
|
||||
<li><code>1 <= wordDict.length <= 1000</code></li>
|
||||
<li><code>1 <= wordDict[i].length <= 20</code></li>
|
||||
<li><code>s</code> 和 <code>wordDict[i]</code> 仅有小写英文字母组成</li>
|
||||
<li><code>wordDict</code> 中的所有字符串 <strong>互不相同</strong></li>
|
||||
</ul>
|
||||
47
算法题（国内版）/problem (Chinese)/单词接龙 II [word-ladder-ii].html
Normal file
47
算法题（国内版）/problem (Chinese)/单词接龙 II [word-ladder-ii].html
Normal file
@@ -0,0 +1,47 @@
|
||||
<p>按字典 <code>wordList</code> 完成从单词 <code>beginWord</code> 到单词 <code>endWord</code> 转化，一个表示此过程的 <strong>转换序列</strong> 是形式上像 <code>beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub></code> 这样的单词序列，并满足：</p>
|
||||
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<ul>
|
||||
<li>每对相邻的单词之间仅有单个字母不同。</li>
|
||||
<li>转换过程中的每个单词 <code>s<sub>i</sub></code>（<code>1 <= i <= k</code>）必须是字典 <code>wordList</code> 中的单词。注意，<code>beginWord</code> 不必是字典 <code>wordList</code> 中的单词。</li>
|
||||
<li><code>s<sub>k</sub> == endWord</code></li>
|
||||
</ul>
|
||||
|
||||
<p>给你两个单词 <code>beginWord</code> 和 <code>endWord</code> ，以及一个字典 <code>wordList</code> 。请你找出并返回所有从 <code>beginWord</code> 到 <code>endWord</code> 的 <strong>最短转换序列</strong> ，如果不存在这样的转换序列，返回一个空列表。每个序列都应该以单词列表<em> </em><code>[beginWord, s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub>]</code> 的形式返回。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
|
||||
<strong>输出：</strong>[["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
|
||||
<strong>解释：</strong>存在 2 种最短的转换序列：
|
||||
"hit" -> "hot" -> "dot" -> "dog" -> "cog"
|
||||
"hit" -> "hot" -> "lot" -> "log" -> "cog"
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
|
||||
<strong>输出：</strong>[]
|
||||
<strong>解释：</strong>endWord "cog" 不在字典 wordList 中，所以不存在符合要求的转换序列。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= beginWord.length <= 5</code></li>
|
||||
<li><code>endWord.length == beginWord.length</code></li>
|
||||
<li><code>1 <= wordList.length <= 5000</code></li>
|
||||
<li><code>wordList[i].length == beginWord.length</code></li>
|
||||
<li><code>beginWord</code>、<code>endWord</code> 和 <code>wordList[i]</code> 由小写英文字母组成</li>
|
||||
<li><code>beginWord != endWord</code></li>
|
||||
<li><code>wordList</code> 中的所有单词 <strong>互不相同</strong></li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user