mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-12 10:51:42 +08:00
add leetcode problem-cn part6
This commit is contained in:
37
算法题（国内版）/problem (English)/2 的幂(English) [power-of-two].html
Normal file
37
算法题（国内版）/problem (English)/2 的幂(English) [power-of-two].html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of two. Otherwise, return <code>false</code></em>.</p>
|
||||
|
||||
<p>An integer <code>n</code> is a power of two, if there exists an integer <code>x</code> such that <code>n == 2<sup>x</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation: </strong>2<sup>0</sup> = 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 16
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation: </strong>2<sup>4</sup> = 16
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you solve it without loops/recursion?
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of three. Otherwise, return <code>false</code></em>.</p>
|
||||
|
||||
<p>An integer <code>n</code> is a power of three, if there exists an integer <code>x</code> such that <code>n == 3<sup>x</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 27
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 0
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 9
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you solve it without loops/recursion?
|
||||
24
算法题（国内版）/problem (English)/4的幂(English) [power-of-four].html
Normal file
24
算法题（国内版）/problem (English)/4的幂(English) [power-of-four].html
Normal file
@@ -0,0 +1,24 @@
|
||||
<p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of four. Otherwise, return <code>false</code></em>.</p>
|
||||
|
||||
<p>An integer <code>n</code> is a power of four, if there exists an integer <code>x</code> such that <code>n == 4<sup>x</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 16
|
||||
<strong>Output:</strong> true
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> false
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Could you solve it without loops/recursion?
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>Given a string <code>columnTitle</code> that represents the column title as appear in an Excel sheet, return <em>its corresponding column number</em>.</p>
|
||||
|
||||
<p>For example:</p>
|
||||
|
||||
<pre>
|
||||
A -> 1
|
||||
B -> 2
|
||||
C -> 3
|
||||
...
|
||||
Z -> 26
|
||||
AA -> 27
|
||||
AB -> 28
|
||||
...
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnTitle = "A"
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnTitle = "AB"
|
||||
<strong>Output:</strong> 28
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnTitle = "ZY"
|
||||
<strong>Output:</strong> 701
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= columnTitle.length <= 7</code></li>
|
||||
<li><code>columnTitle</code> consists only of uppercase English letters.</li>
|
||||
<li><code>columnTitle</code> is in the range <code>["A", "FXSHRXW"]</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>Given an integer <code>columnNumber</code>, return <em>its corresponding column title as it appears in an Excel sheet</em>.</p>
|
||||
|
||||
<p>For example:</p>
|
||||
|
||||
<pre>
|
||||
A -> 1
|
||||
B -> 2
|
||||
C -> 3
|
||||
...
|
||||
Z -> 26
|
||||
AA -> 27
|
||||
AB -> 28
|
||||
...
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnNumber = 1
|
||||
<strong>Output:</strong> "A"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnNumber = 28
|
||||
<strong>Output:</strong> "AB"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> columnNumber = 701
|
||||
<strong>Output:</strong> "ZY"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= columnNumber <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Given an integer <code>n</code>, return <em>a string array </em><code>answer</code><em> (<strong>1-indexed</strong>) where</em>:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>answer[i] == "FizzBuzz"</code> if <code>i</code> is divisible by <code>3</code> and <code>5</code>.</li>
|
||||
<li><code>answer[i] == "Fizz"</code> if <code>i</code> is divisible by <code>3</code>.</li>
|
||||
<li><code>answer[i] == "Buzz"</code> if <code>i</code> is divisible by <code>5</code>.</li>
|
||||
<li><code>answer[i] == i</code> (as a string) if none of the above conditions are true.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 3
|
||||
<strong>Output:</strong> ["1","2","Fizz"]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 5
|
||||
<strong>Output:</strong> ["1","2","Fizz","4","Buzz"]
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> n = 15
|
||||
<strong>Output:</strong> ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given an array of integers <code>citations</code> where <code>citations[i]</code> is the number of citations a researcher received for their <code>i<sup>th</sup></code> paper and <code>citations</code> is sorted in an <strong>ascending order</strong>, return compute the researcher's <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p>According to the <a href="https://en.wikipedia.org/wiki/H-index" target="_blank">definition of h-index on Wikipedia</a>: A scientist has an index <code>h</code> if <code>h</code> of their <code>n</code> papers have at least <code>h</code> citations each, and the other <code>n − h</code> papers have no more than <code>h</code> citations each.</p>
|
||||
|
||||
<p>If there are several possible values for <code>h</code>, the maximum one is taken as the <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p>You must write an algorithm that runs in logarithmic time.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [0,1,3,5,6]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> [0,1,3,5,6] means the researcher has 5 papers in total and each of them had received 0, 1, 3, 5, 6 citations respectively.
|
||||
Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, their h-index is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [1,2,100]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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> is sorted in <strong>ascending order</strong>.</li>
|
||||
</ul>
|
||||
31
算法题（国内版）/problem (English)/H 指数(English) [h-index].html
Normal file
31
算法题（国内版）/problem (English)/H 指数(English) [h-index].html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>Given an array of integers <code>citations</code> where <code>citations[i]</code> is the number of citations a researcher received for their <code>i<sup>th</sup></code> paper, return compute the researcher's <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p>According to the <a href="https://en.wikipedia.org/wiki/H-index" target="_blank">definition of h-index on Wikipedia</a>: A scientist has an index <code>h</code> if <code>h</code> of their <code>n</code> papers have at least <code>h</code> citations each, and the other <code>n − h</code> papers have no more than <code>h</code> citations each.</p>
|
||||
|
||||
<p>If there are several possible values for <code>h</code>, the maximum one is taken as the <code>h</code><strong>-index</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [3,0,6,1,5]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> [3,0,6,1,5] means the researcher has 5 papers in total and each of them had received 3, 0, 6, 1, 5 citations respectively.
|
||||
Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, their h-index is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> citations = [1,3,1]
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,32 @@
|
||||
<p>Given the <code>head</code> of a linked list, reverse the nodes of the list <code>k</code> at a time, and return <em>the modified list</em>.</p>
|
||||
|
||||
<p><code>k</code> is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of <code>k</code> then left-out nodes, in the end, should remain as it is.</p>
|
||||
|
||||
<p>You may not alter the values in the list's nodes, only nodes themselves may be changed.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,4,5], k = 2
|
||||
<strong>Output:</strong> [2,1,4,3,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,4,5], k = 3
|
||||
<strong>Output:</strong> [3,2,1,4,5]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the list is <code>n</code>.</li>
|
||||
<li><code>1 <= k <= n <= 5000</code></li>
|
||||
<li><code>0 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow-up:</strong> Can you solve the problem in <code>O(1)</code> extra memory space?</p>
|
||||
44
算法题（国内版）/problem (English)/LRU 缓存(English) [lru-cache].html
Normal file
44
算法题（国内版）/problem (English)/LRU 缓存(English) [lru-cache].html
Normal file
@@ -0,0 +1,44 @@
|
||||
<p>Design a data structure that follows the constraints of a <strong><a href="https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU" target="_blank">Least Recently Used (LRU) cache</a></strong>.</p>
|
||||
|
||||
<p>Implement the <code>LRUCache</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>LRUCache(int capacity)</code> Initialize the LRU cache with <strong>positive</strong> size <code>capacity</code>.</li>
|
||||
<li><code>int get(int key)</code> Return the value of the <code>key</code> if the key exists, otherwise return <code>-1</code>.</li>
|
||||
<li><code>void put(int key, int value)</code> Update the value of the <code>key</code> if the <code>key</code> exists. Otherwise, add the <code>key-value</code> pair to the cache. If the number of keys exceeds the <code>capacity</code> from this operation, <strong>evict</strong> the least recently used key.</li>
|
||||
</ul>
|
||||
|
||||
<p>The functions <code data-stringify-type="code">get</code> and <code data-stringify-type="code">put</code> must each run in <code>O(1)</code> average time complexity.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</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>Output</strong>
|
||||
[null, null, null, 1, null, -1, null, -1, 3, 4]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
LRUCache lRUCache = new LRUCache(2);
|
||||
lRUCache.put(1, 1); // cache is {1=1}
|
||||
lRUCache.put(2, 2); // cache is {1=1, 2=2}
|
||||
lRUCache.get(1); // return 1
|
||||
lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
|
||||
lRUCache.get(2); // returns -1 (not found)
|
||||
lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
|
||||
lRUCache.get(1); // return -1 (not found)
|
||||
lRUCache.get(3); // return 3
|
||||
lRUCache.get(4); // return 4
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= capacity <= 3000</code></li>
|
||||
<li><code>0 <= key <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= value <= 10<sup>5</sup></code></li>
|
||||
<li>At most 2<code> * 10<sup>5</sup></code> calls will be made to <code>get</code> and <code>put</code>.</li>
|
||||
</ul>
|
||||
28
算法题（国内版）/problem (English)/N 皇后(English) [n-queens].html
Normal file
28
算法题（国内版）/problem (English)/N 皇后(English) [n-queens].html
Normal file
@@ -0,0 +1,28 @@
|
||||
<p>The <strong>n-queens</strong> puzzle is the problem of placing <code>n</code> queens on an <code>n x n</code> chessboard such that no two queens attack each other.</p>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <em>all distinct solutions to the <strong>n-queens puzzle</strong></em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p>Each solution contains a distinct board configuration of the n-queens' placement, where <code>'Q'</code> and <code>'.'</code> both indicate a queen and an empty space, respectively.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
|
||||
<strong>Explanation:</strong> There exist two distinct solutions to the 4-queens puzzle as shown above
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> [["Q"]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 9</code></li>
|
||||
</ul>
|
||||
44
算法题（国内版）/problem (English)/Nim 游戏(English) [nim-game].html
Normal file
44
算法题（国内版）/problem (English)/Nim 游戏(English) [nim-game].html
Normal file
@@ -0,0 +1,44 @@
|
||||
<p>You are playing the following Nim Game with your friend:</p>
|
||||
|
||||
<ul>
|
||||
<li>Initially, there is a heap of stones on the table.</li>
|
||||
<li>You and your friend will alternate taking turns, and <strong>you go first</strong>.</li>
|
||||
<li>On each turn, the person whose turn it is will remove 1 to 3 stones from the heap.</li>
|
||||
<li>The one who removes the last stone is the winner.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given <code>n</code>, the number of stones in the heap, return <code>true</code><em> if you can win the game assuming both you and your friend play optimally, otherwise return </em><code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> These are the possible outcomes:
|
||||
1. You remove 1 stone. Your friend removes 3 stones, including the last stone. Your friend wins.
|
||||
2. You remove 2 stones. Your friend removes 2 stones, including the last stone. Your friend wins.
|
||||
3. You remove 3 stones. Your friend removes the last stone. Your friend wins.
|
||||
In all outcomes, your friend wins.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 2
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>The <strong>n-queens</strong> puzzle is the problem of placing <code>n</code> queens on an <code>n x n</code> chessboard such that no two queens attack each other.</p>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <em>the number of distinct solutions to the <strong>n-queens puzzle</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> There are two distinct solutions to the 4-queens puzzle as shown.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p><code>RandomizedCollection</code> is a data structure that contains a collection of numbers, possibly duplicates (i.e., a multiset). It should support inserting and removing specific elements and also removing a random element.</p>
|
||||
|
||||
<p>Implement the <code>RandomizedCollection</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RandomizedCollection()</code> Initializes the empty <code>RandomizedCollection</code> object.</li>
|
||||
<li><code>bool insert(int val)</code> Inserts an item <code>val</code> into the multiset, even if the item is already present. Returns <code>true</code> if the item is not present, <code>false</code> otherwise.</li>
|
||||
<li><code>bool remove(int val)</code> Removes an item <code>val</code> from the multiset if present. Returns <code>true</code> if the item is present, <code>false</code> otherwise. Note that if <code>val</code> has multiple occurrences in the multiset, we only remove one of them.</li>
|
||||
<li><code>int getRandom()</code> Returns a random element from the current multiset of elements. The probability of each element being returned is <strong>linearly related</strong> to the number of same values the multiset contains.</li>
|
||||
</ul>
|
||||
|
||||
<p>You must implement the functions of the class such that each function works on <strong>average</strong> <code>O(1)</code> time complexity.</p>
|
||||
|
||||
<p><strong>Note:</strong> The test cases are generated such that <code>getRandom</code> will only be called if there is <strong>at least one</strong> item in the <code>RandomizedCollection</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["RandomizedCollection", "insert", "insert", "insert", "getRandom", "remove", "getRandom"]
|
||||
[[], [1], [1], [2], [], [1], []]
|
||||
<strong>Output</strong>
|
||||
[null, true, false, true, 2, true, 1]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
RandomizedCollection randomizedCollection = new RandomizedCollection();
|
||||
randomizedCollection.insert(1); // return true since the collection does not contain 1.
|
||||
// Inserts 1 into the collection.
|
||||
randomizedCollection.insert(1); // return false since the collection contains 1.
|
||||
// Inserts another 1 into the collection. Collection now contains [1,1].
|
||||
randomizedCollection.insert(2); // return true since the collection does not contain 2.
|
||||
// Inserts 2 into the collection. Collection now contains [1,1,2].
|
||||
randomizedCollection.getRandom(); // getRandom should:
|
||||
// - return 1 with probability 2/3, or
|
||||
// - return 2 with probability 1/3.
|
||||
randomizedCollection.remove(1); // return true since the collection contains 1.
|
||||
// Removes 1 from the collection. Collection now contains [1,2].
|
||||
randomizedCollection.getRandom(); // getRandom should return 1 or 2, both equally likely.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code></li>
|
||||
<li>At most <code>2 * 10<sup>5</sup></code> calls <strong>in total</strong> will be made to <code>insert</code>, <code>remove</code>, and <code>getRandom</code>.</li>
|
||||
<li>There will be <strong>at least one</strong> element in the data structure when <code>getRandom</code> is called.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>Implement the <code>RandomizedSet</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>RandomizedSet()</code> Initializes the <code>RandomizedSet</code> object.</li>
|
||||
<li><code>bool insert(int val)</code> Inserts an item <code>val</code> into the set if not present. Returns <code>true</code> if the item was not present, <code>false</code> otherwise.</li>
|
||||
<li><code>bool remove(int val)</code> Removes an item <code>val</code> from the set if present. Returns <code>true</code> if the item was present, <code>false</code> otherwise.</li>
|
||||
<li><code>int getRandom()</code> Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the <b>same probability</b> of being returned.</li>
|
||||
</ul>
|
||||
|
||||
<p>You must implement the functions of the class such that each function works in <strong>average</strong> <code>O(1)</code> time complexity.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
|
||||
[[], [1], [2], [2], [], [1], [2], []]
|
||||
<strong>Output</strong>
|
||||
[null, true, false, true, 2, true, false, 2]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
RandomizedSet randomizedSet = new RandomizedSet();
|
||||
randomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully.
|
||||
randomizedSet.remove(2); // Returns false as 2 does not exist in the set.
|
||||
randomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2].
|
||||
randomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly.
|
||||
randomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2].
|
||||
randomizedSet.insert(2); // 2 was already in the set, so return false.
|
||||
randomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code></li>
|
||||
<li>At most <code>2 * </code><code>10<sup>5</sup></code> calls will be made to <code>insert</code>, <code>remove</code>, and <code>getRandom</code>.</li>
|
||||
<li>There will be <strong>at least one</strong> element in the data structure when <code>getRandom</code> is called.</li>
|
||||
</ul>
|
||||
33
算法题（国内版）/problem (English)/Pow(x, n)(English) [powx-n].html
Normal file
33
算法题（国内版）/problem (English)/Pow(x, n)(English) [powx-n].html
Normal file
@@ -0,0 +1,33 @@
|
||||
<p>Implement <a href="http://www.cplusplus.com/reference/valarray/pow/" target="_blank">pow(x, n)</a>, which calculates <code>x</code> raised to the power <code>n</code> (i.e., <code>x<sup>n</sup></code>).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 2.00000, n = 10
|
||||
<strong>Output:</strong> 1024.00000
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 2.10000, n = 3
|
||||
<strong>Output:</strong> 9.26100
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 2.00000, n = -2
|
||||
<strong>Output:</strong> 0.25000
|
||||
<strong>Explanation:</strong> 2<sup>-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,51 @@
|
||||
<p>Given an integer array <code>data</code> representing the data, return whether it is a valid <strong>UTF-8</strong> encoding.</p>
|
||||
|
||||
<p>A character in <strong>UTF8</strong> can be from <b>1 to 4 bytes</b> long, subjected to the following rules:</p>
|
||||
|
||||
<ol>
|
||||
<li>For a <strong>1-byte</strong> character, the first bit is a <code>0</code>, followed by its Unicode code.</li>
|
||||
<li>For an <strong>n-bytes</strong> character, the first <code>n</code> bits are all one's, the <code>n + 1</code> bit is <code>0</code>, followed by <code>n - 1</code> bytes with the most significant <code>2</code> bits being <code>10</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>This is how the UTF-8 encoding would work:</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><b>Note: </b>The input is an array of integers. Only the <b>least significant 8 bits</b> of each integer is used to store the data. This means each integer represents only 1 byte of data.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> data = [197,130,1]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> data represents the octet sequence: 11000101 10000010 00000001.
|
||||
It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> data = [235,140,4]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> data represented the octet sequence: 11101011 10001100 00000100.
|
||||
The first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character.
|
||||
The next byte is a continuation byte which starts with 10 and that's correct.
|
||||
But the second continuation byte does not start with 10, so it is invalid.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= data.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= data[i] <= 255</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>The string <code>"PAYPALISHIRING"</code> is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)</p>
|
||||
|
||||
<pre>
|
||||
P A H N
|
||||
A P L S I I G
|
||||
Y I R
|
||||
</pre>
|
||||
|
||||
<p>And then read line by line: <code>"PAHNAPLSIIGYIR"</code></p>
|
||||
|
||||
<p>Write the code that will take a string and make this conversion given a number of rows:</p>
|
||||
|
||||
<pre>
|
||||
string convert(string s, int numRows);
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "PAYPALISHIRING", numRows = 3
|
||||
<strong>Output:</strong> "PAHNAPLSIIGYIR"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "PAYPALISHIRING", numRows = 4
|
||||
<strong>Output:</strong> "PINALSIGYAHRPI"
|
||||
<strong>Explanation:</strong>
|
||||
P I N
|
||||
A L S I G
|
||||
Y A H R
|
||||
P I
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "A", numRows = 1
|
||||
<strong>Output:</strong> "A"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s</code> consists of English letters (lower-case and upper-case), <code>','</code> and <code>'.'</code>.</li>
|
||||
<li><code>1 <= numRows <= 1000</code></li>
|
||||
</ul>
|
||||
27
算法题（国内版）/problem (English)/x 的平方根 (English) [sqrtx].html
Normal file
27
算法题（国内版）/problem (English)/x 的平方根 (English) [sqrtx].html
Normal file
@@ -0,0 +1,27 @@
|
||||
<p>Given a non-negative integer <code>x</code>, compute and return <em>the square root of</em> <code>x</code>.</p>
|
||||
|
||||
<p>Since the return type is an integer, the decimal digits are <strong>truncated</strong>, and only <strong>the integer part</strong> of the result is returned.</p>
|
||||
|
||||
<p><strong>Note: </strong>You are not allowed to use any built-in exponent function or operator, such as <code>pow(x, 0.5)</code> or <code>x ** 0.5</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 4
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> x = 8
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= x <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
22
算法题（国内版）/problem (English)/三数之和(English) [3sum].html
Normal file
22
算法题（国内版）/problem (English)/三数之和(English) [3sum].html
Normal file
@@ -0,0 +1,22 @@
|
||||
<p>Given an integer array nums, return all the triplets <code>[nums[i], nums[j], nums[k]]</code> such that <code>i != j</code>, <code>i != k</code>, and <code>j != k</code>, and <code>nums[i] + nums[j] + nums[k] == 0</code>.</p>
|
||||
|
||||
<p>Notice that the solution set must not contain duplicate triplets.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [-1,0,1,2,-1,-4]
|
||||
<strong>Output:</strong> [[-1,-1,2],[-1,0,1]]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = []
|
||||
<strong>Output:</strong> []
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [0]
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>
|
||||
37
算法题（国内版）/problem (English)/三角形最小路径和(English) [triangle].html
Normal file
37
算法题（国内版）/problem (English)/三角形最小路径和(English) [triangle].html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>Given a <code>triangle</code> array, return <em>the minimum path sum from top to bottom</em>.</p>
|
||||
|
||||
<p>For each step, you may move to an adjacent number of the row below. More formally, if you are on index <code>i</code> on the current row, you may move to either index <code>i</code> or index <code>i + 1</code> on the next row.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
|
||||
<strong>Output:</strong> 11
|
||||
<strong>Explanation:</strong> The triangle looks like:
|
||||
<u>2</u>
|
||||
<u>3</u> 4
|
||||
6 <u>5</u> 7
|
||||
4 <u>1</u> 8 3
|
||||
The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> triangle = [[-10]]
|
||||
<strong>Output:</strong> -10
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>
|
||||
<strong>Follow up:</strong> Could you do this using only <code>O(n)</code> extra space, where <code>n</code> is the total number of rows in the triangle?
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>Table: <code>Weather</code></p>
|
||||
|
||||
<pre>
|
||||
+---------------+---------+
|
||||
| Column Name | Type |
|
||||
+---------------+---------+
|
||||
| id | int |
|
||||
| recordDate | date |
|
||||
| temperature | int |
|
||||
+---------------+---------+
|
||||
id is the primary key for this table.
|
||||
This table contains information about the temperature on a certain day.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to find all dates' <code>Id</code> with higher temperatures compared to its previous dates (yesterday).</p>
|
||||
|
||||
<p>Return the result table in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Weather table:
|
||||
+----+------------+-------------+
|
||||
| id | recordDate | temperature |
|
||||
+----+------------+-------------+
|
||||
| 1 | 2015-01-01 | 10 |
|
||||
| 2 | 2015-01-02 | 25 |
|
||||
| 3 | 2015-01-03 | 20 |
|
||||
| 4 | 2015-01-04 | 30 |
|
||||
+----+------------+-------------+
|
||||
<strong>Output:</strong>
|
||||
+----+
|
||||
| id |
|
||||
+----+
|
||||
| 2 |
|
||||
| 4 |
|
||||
+----+
|
||||
<strong>Explanation:</strong>
|
||||
In 2015-01-02, the temperature was higher than the previous day (10 -> 25).
|
||||
In 2015-01-04, the temperature was higher than the previous day (20 -> 30).
|
||||
</pre>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>A <strong>permutation</strong> of an array of integers is an arrangement of its members into a sequence or linear order.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, for <code>arr = [1,2,3]</code>, the following are considered permutations of <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>The <strong>next permutation</strong> of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the <strong>next permutation</strong> of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order).</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, the next permutation of <code>arr = [1,2,3]</code> is <code>[1,3,2]</code>.</li>
|
||||
<li>Similarly, the next permutation of <code>arr = [2,3,1]</code> is <code>[3,1,2]</code>.</li>
|
||||
<li>While the next permutation of <code>arr = [3,2,1]</code> is <code>[1,2,3]</code> because <code>[3,2,1]</code> does not have a lexicographical larger rearrangement.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an array of integers <code>nums</code>, <em>find the next permutation of</em> <code>nums</code>.</p>
|
||||
|
||||
<p>The replacement must be <strong><a href="http://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in place</a></strong> and use only constant extra memory.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> [1,3,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,2,1]
|
||||
<strong>Output:</strong> [1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,5]
|
||||
<strong>Output:</strong> [1,5,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>0 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,23 @@
|
||||
<p>Given an integer <code>n</code>, return <em>all the structurally unique <strong>BST'</strong>s (binary search trees), which has exactly </em><code>n</code><em> nodes of unique values from</em> <code>1</code> <em>to</em> <code>n</code>. Return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg" style="width: 600px; height: 148px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3
|
||||
<strong>Output:</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>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> [[1]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 8</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,23 @@
|
||||
<p>Given an integer <code>n</code>, return <em>the number of structurally unique <strong>BST'</strong>s (binary search trees) which has exactly </em><code>n</code><em> nodes of unique values from</em> <code>1</code> <em>to</em> <code>n</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg" style="width: 600px; height: 148px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 19</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given two strings <code>s</code> and <code>t</code>, return <em>the number of distinct subsequences of <code>s</code> which equals <code>t</code></em>.</p>
|
||||
|
||||
<p>A string's <strong>subsequence</strong> is a new string formed from the original string by deleting some (can be none) of the characters without disturbing the remaining characters' relative positions. (i.e., <code>"ACE"</code> is a subsequence of <code>"ABCDE"</code> while <code>"AEC"</code> is not).</p>
|
||||
|
||||
<p>The test cases are generated so that the answer fits on a 32-bit signed integer.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "rabbbit", t = "rabbit"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong>
|
||||
As shown below, there are 3 ways you can generate "rabbit" from S.
|
||||
<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>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "babgbag", t = "bag"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
As shown below, there are 5 ways you can generate "bag" from S.
|
||||
<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>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length, t.length <= 1000</code></li>
|
||||
<li><code>s</code> and <code>t</code> consist of English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>A robot is located at the top-left corner of a <code>m x n</code> grid (marked 'Start' in the diagram below).</p>
|
||||
|
||||
<p>The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).</p>
|
||||
|
||||
<p>Now consider if some obstacles are added to the grids. How many unique paths would there be?</p>
|
||||
|
||||
<p>An obstacle and space is marked as <code>1</code> and <code>0</code> respectively in the grid.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg" style="width: 242px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> There is one obstacle in the middle of the 3x3 grid above.
|
||||
There are two ways to reach the bottom-right corner:
|
||||
1. Right -> Right -> Down -> Down
|
||||
2. Down -> Down -> Right -> Right
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg" style="width: 162px; height: 162px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> obstacleGrid = [[0,1],[0,0]]
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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> is <code>0</code> or <code>1</code>.</li>
|
||||
</ul>
|
||||
31
算法题（国内版）/problem (English)/不同路径(English) [unique-paths].html
Normal file
31
算法题（国内版）/problem (English)/不同路径(English) [unique-paths].html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>There is a robot on an <code>m x n</code> grid. The robot is initially located at the <strong>top-left corner</strong> (i.e., <code>grid[0][0]</code>). The robot tries to move to the <strong>bottom-right corner</strong> (i.e., <code>grid[m - 1][n - 1]</code>). The robot can only move either down or right at any point in time.</p>
|
||||
|
||||
<p>Given the two integers <code>m</code> and <code>n</code>, return <em>the number of possible unique paths that the robot can take to reach the bottom-right corner</em>.</p>
|
||||
|
||||
<p>The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img src="https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png" style="width: 400px; height: 183px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> m = 3, n = 7
|
||||
<strong>Output:</strong> 28
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> m = 3, n = 2
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
|
||||
1. Right -> Down -> Down
|
||||
2. Down -> Down -> Right
|
||||
3. Down -> Right -> Down
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= m, n <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>An <strong>ugly number</strong> is a positive integer whose prime factors are limited to <code>2</code>, <code>3</code>, and <code>5</code>.</p>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <em>the</em> <code>n<sup>th</sup></code> <em><strong>ugly number</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 10
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> [1, 2, 3, 4, 5, 6, 8, 9, 10, 12] is the sequence of the first 10 ugly numbers.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1690</code></li>
|
||||
</ul>
|
||||
35
算法题（国内版）/problem (English)/丑数(English) [ugly-number].html
Normal file
35
算法题（国内版）/problem (English)/丑数(English) [ugly-number].html
Normal file
@@ -0,0 +1,35 @@
|
||||
<p>An <strong>ugly number</strong> is a positive integer whose prime factors are limited to <code>2</code>, <code>3</code>, and <code>5</code>.</p>
|
||||
|
||||
<p>Given an integer <code>n</code>, return <code>true</code> <em>if</em> <code>n</code> <em>is an <strong>ugly number</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 6
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> 6 = 2 × 3
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 14
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> 14 is not ugly since it includes the prime factor 7.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given an array <code>nums</code> containing <code>n</code> distinct numbers in the range <code>[0, n]</code>, return <em>the only number in the range that is missing from the array.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,0,1]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,1]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [9,6,4,2,3,5,7,0,1]
|
||||
<strong>Output:</strong> 8
|
||||
<strong>Explanation:</strong> n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>All the numbers of <code>nums</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Could you implement a solution using only <code>O(1)</code> extra space complexity and <code>O(n)</code> runtime complexity?</p>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg" style="width: 422px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,4]
|
||||
<strong>Output:</strong> [2,1,4,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1]
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the list is in the range <code>[0, 100]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given two integer arrays <code>nums1</code> and <code>nums2</code>, return <em>an array of their intersection</em>. Each element in the result must appear as many times as it shows in both arrays and you may return the result in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,2,2,1], nums2 = [2,2]
|
||||
<strong>Output:</strong> [2,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [4,9,5], nums2 = [9,4,9,8,4]
|
||||
<strong>Output:</strong> [4,9]
|
||||
<strong>Explanation:</strong> [9,4] is also accepted.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>Follow up:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>What if the given array is already sorted? How would you optimize your algorithm?</li>
|
||||
<li>What if <code>nums1</code>'s size is small compared to <code>nums2</code>'s size? Which algorithm is better?</li>
|
||||
<li>What if elements of <code>nums2</code> are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,25 @@
|
||||
<p>Given two integer arrays <code>nums1</code> and <code>nums2</code>, return <em>an array of their intersection</em>. Each element in the result must be <strong>unique</strong> and you may return the result in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,2,2,1], nums2 = [2,2]
|
||||
<strong>Output:</strong> [2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [4,9,5], nums2 = [9,4,9,8,4]
|
||||
<strong>Output:</strong> [9,4]
|
||||
<strong>Explanation:</strong> [4,9] is also accepted.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,43 @@
|
||||
<p>Given a <strong>1-indexed</strong> array of integers <code>numbers</code> that is already <strong><em>sorted in non-decreasing order</em></strong>, find two numbers such that they add up to a specific <code>target</code> number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 <= index<sub>1</sub> < index<sub>2</sub> <= numbers.length</code>.</p>
|
||||
|
||||
<p>Return<em> the indices of the two numbers, </em><code>index<sub>1</sub></code><em> and </em><code>index<sub>2</sub></code><em>, <strong>added by one</strong> as an integer array </em><code>[index<sub>1</sub>, index<sub>2</sub>]</code><em> of length 2.</em></p>
|
||||
|
||||
<p>The tests are generated such that there is <strong>exactly one solution</strong>. You <strong>may not</strong> use the same element twice.</p>
|
||||
|
||||
<p>Your solution must use only constant extra space.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numbers = [<u>2</u>,<u>7</u>,11,15], target = 9
|
||||
<strong>Output:</strong> [1,2]
|
||||
<strong>Explanation:</strong> The sum of 2 and 7 is 9. Therefore, index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numbers = [<u>2</u>,3,<u>4</u>], target = 6
|
||||
<strong>Output:</strong> [1,3]
|
||||
<strong>Explanation:</strong> The sum of 2 and 4 is 6. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 3. We return [1, 3].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numbers = [<u>-1</u>,<u>0</u>], target = -1
|
||||
<strong>Output:</strong> [1,2]
|
||||
<strong>Explanation:</strong> The sum of -1 and 0 is -1. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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> is sorted in <strong>non-decreasing order</strong>.</li>
|
||||
<li><code>-1000 <= target <= 1000</code></li>
|
||||
<li>The tests are generated such that there is <strong>exactly one solution</strong>.</li>
|
||||
</ul>
|
||||
41
算法题（国内版）/problem (English)/两数之和(English) [two-sum].html
Normal file
41
算法题（国内版）/problem (English)/两数之和(English) [two-sum].html
Normal file
@@ -0,0 +1,41 @@
|
||||
<p>Given an array of integers <code>nums</code> and an integer <code>target</code>, return <em>indices of the two numbers such that they add up to <code>target</code></em>.</p>
|
||||
|
||||
<p>You may assume that each input would have <strong><em>exactly</em> one solution</strong>, and you may not use the <em>same</em> element twice.</p>
|
||||
|
||||
<p>You can return the answer in any order.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,7,11,15], target = 9
|
||||
<strong>Output:</strong> [0,1]
|
||||
<strong>Explanation:</strong> Because nums[0] + nums[1] == 9, we return [0, 1].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,2,4], target = 6
|
||||
<strong>Output:</strong> [1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,3], target = 6
|
||||
<strong>Output:</strong> [0,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>Only one valid answer exists.</strong></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow-up: </strong>Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>) </code>time complexity?
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>You are given two <strong>non-empty</strong> linked lists representing two non-negative integers. The digits are stored in <strong>reverse order</strong>, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.</p>
|
||||
|
||||
<p>You may assume the two numbers do not contain any leading zero, except the number 0 itself.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg" style="width: 483px; height: 342px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [2,4,3], l2 = [5,6,4]
|
||||
<strong>Output:</strong> [7,0,8]
|
||||
<strong>Explanation:</strong> 342 + 465 = 807.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [0], l2 = [0]
|
||||
<strong>Output:</strong> [0]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
|
||||
<strong>Output:</strong> [8,9,9,9,0,0,0,1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in each linked list is in the range <code>[1, 100]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 9</code></li>
|
||||
<li>It is guaranteed that the list represents a number that does not have leading zeros.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>Given two integers <code>dividend</code> and <code>divisor</code>, divide two integers <strong>without</strong> using multiplication, division, and mod operator.</p>
|
||||
|
||||
<p>The integer division should truncate toward zero, which means losing its fractional part. For example, <code>8.345</code> would be truncated to <code>8</code>, and <code>-2.7335</code> would be truncated to <code>-2</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>quotient</strong> after dividing </em><code>dividend</code><em> by </em><code>divisor</code>.</p>
|
||||
|
||||
<p><strong>Note: </strong>Assume we are dealing with an environment that could only store integers within the <strong>32-bit</strong> signed integer range: <code>[−2<sup>31</sup>, 2<sup>31</sup> − 1]</code>. For this problem, if the quotient is <strong>strictly greater than</strong> <code>2<sup>31</sup> - 1</code>, then return <code>2<sup>31</sup> - 1</code>, and if the quotient is <strong>strictly less than</strong> <code>-2<sup>31</sup></code>, then return <code>-2<sup>31</sup></code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> dividend = 10, divisor = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> 10/3 = 3.33333.. which is truncated to 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> dividend = 7, divisor = -3
|
||||
<strong>Output:</strong> -2
|
||||
<strong>Explanation:</strong> 7/-3 = -2.33333.. which is truncated to -2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-2<sup>31</sup> <= dividend, divisor <= 2<sup>31</sup> - 1</code></li>
|
||||
<li><code>divisor != 0</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,16 @@
|
||||
<p>Given two integers <code>a</code> and <code>b</code>, return <em>the sum of the two integers without using the operators</em> <code>+</code> <em>and</em> <code>-</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> a = 1, b = 2
|
||||
<strong>Output:</strong> 3
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> a = 2, b = 3
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>-1000 <= a, b <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>You are given a string <code>s</code> and an array of strings <code>words</code> of <strong>the same length</strong>. Return all starting indices of substring(s) in <code>s</code> that is a concatenation of each word in <code>words</code> <strong>exactly once</strong>, <strong>in any order</strong>, and <strong>without any intervening characters</strong>.</p>
|
||||
|
||||
<p>You can return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "barfoothefoobarman", words = ["foo","bar"]
|
||||
<strong>Output:</strong> [0,9]
|
||||
<strong>Explanation:</strong> Substrings starting at index 0 and 9 are "barfoo" and "foobar" respectively.
|
||||
The output order does not matter, returning [9,0] is fine too.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
|
||||
<strong>Output:</strong> [6,9,12]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>s</code> consists of lower-case English letters.</li>
|
||||
<li><code>1 <= words.length <= 5000</code></li>
|
||||
<li><code>1 <= words[i].length <= 30</code></li>
|
||||
<li><code>words[i]</code> consists of lower-case English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given a string <code>expression</code> of numbers and operators, return <em>all possible results from computing all the different possible ways to group numbers and operators</em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "2-1-1"
|
||||
<strong>Output:</strong> [0,2]
|
||||
<strong>Explanation:</strong>
|
||||
((2-1)-1) = 0
|
||||
(2-(1-1)) = 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> expression = "2*3-4*5"
|
||||
<strong>Output:</strong> [-34,-14,-10,-10,10]
|
||||
<strong>Explanation:</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>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= expression.length <= 20</code></li>
|
||||
<li><code>expression</code> consists of digits and the operator <code>'+'</code>, <code>'-'</code>, and <code>'*'</code>.</li>
|
||||
<li>All the integer values in the input expression are in the range <code>[0, 99]</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given an integer array <code>nums</code>, find a contiguous non-empty subarray within the array that has the largest product, and return <em>the product</em>.</p>
|
||||
|
||||
<p>The test cases are generated so that the answer will fit in a <strong>32-bit</strong> integer.</p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous subsequence of the array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,3,-2,4]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> [2,3] has the largest product 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-2,0,-1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> The result cannot be 2, because [-2,-1] is not a subarray.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>-10 <= nums[i] <= 10</code></li>
|
||||
<li>The product of any prefix or suffix of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given an integer array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
|
||||
|
||||
<p>On each day, you may decide to buy and/or sell the stock. You can only hold <strong>at most one</strong> share of the stock at any time. However, you can buy it then immediately sell it on the <strong>same day</strong>.</p>
|
||||
|
||||
<p>Find and return <em>the <strong>maximum</strong> profit you can achieve</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,1,5,3,6,4]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
|
||||
Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
|
||||
Total profit is 4 + 3 = 7.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
|
||||
Total profit is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,6,4,3,1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,39 @@
|
||||
<p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
|
||||
|
||||
<p>Find the maximum profit you can achieve. You may complete <strong>at most two transactions</strong>.</p>
|
||||
|
||||
<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [3,3,5,0,0,3,1,4]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
|
||||
Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
|
||||
Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,6,4,3,1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> In this case, no transaction is done, i.e. max profit = 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,31 @@
|
||||
<p>You are given an integer array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer <code>k</code>.</p>
|
||||
|
||||
<p>Find the maximum profit you can achieve. You may complete at most <code>k</code> transactions.</p>
|
||||
|
||||
<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 2, prices = [2,4,1]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> k = 2, prices = [3,2,6,5,0,3]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,31 @@
|
||||
<p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
|
||||
|
||||
<p>You want to maximize your profit by choosing a <strong>single day</strong> to buy one stock and choosing a <strong>different day in the future</strong> to sell that stock.</p>
|
||||
|
||||
<p>Return <em>the maximum profit you can achieve from this transaction</em>. If you cannot achieve any profit, return <code>0</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,1,5,3,6,4]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
|
||||
Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [7,6,4,3,1]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> In this case, no transactions are done and the max profit = 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,28 @@
|
||||
<p>Given the <code>root</code> of a binary search tree, and an integer <code>k</code>, return <em>the</em> <code>k<sup>th</sup></code> <em>smallest value (<strong>1-indexed</strong>) of all the values of the nodes in the tree</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg" style="width: 212px; height: 301px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,1,4,null,2], k = 1
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg" style="width: 382px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [5,3,6,2,4,null,null,1], k = 3
|
||||
<strong>Output:</strong> 3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is <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>Follow up:</strong> If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?</p>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.</p>
|
||||
|
||||
<p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [2,1], p = 2, q = 1
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
|
||||
<li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li>
|
||||
<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
|
||||
<li><code>p != q</code></li>
|
||||
<li><code>p</code> and <code>q</code> will exist in the BST.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>Implement the <code>BSTIterator</code> class that represents an iterator over the <strong><a href="https://en.wikipedia.org/wiki/Tree_traversal#In-order_(LNR)" target="_blank">in-order traversal</a></strong> of a binary search tree (BST):</p>
|
||||
|
||||
<ul>
|
||||
<li><code>BSTIterator(TreeNode root)</code> Initializes an object of the <code>BSTIterator</code> class. The <code>root</code> of the BST is given as part of the constructor. The pointer should be initialized to a non-existent number smaller than any element in the BST.</li>
|
||||
<li><code>boolean hasNext()</code> Returns <code>true</code> if there exists a number in the traversal to the right of the pointer, otherwise returns <code>false</code>.</li>
|
||||
<li><code>int next()</code> Moves the pointer to the right, then returns the number at the pointer.</li>
|
||||
</ul>
|
||||
|
||||
<p>Notice that by initializing the pointer to a non-existent smallest number, the first call to <code>next()</code> will return the smallest element in the BST.</p>
|
||||
|
||||
<p>You may assume that <code>next()</code> calls will always be valid. That is, there will be at least a next number in the in-order traversal when <code>next()</code> is called.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png" style="width: 189px; height: 178px;" />
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
|
||||
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
|
||||
<strong>Output</strong>
|
||||
[null, 3, 7, true, 9, true, 15, true, 20, false]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
|
||||
bSTIterator.next(); // return 3
|
||||
bSTIterator.next(); // return 7
|
||||
bSTIterator.hasNext(); // return True
|
||||
bSTIterator.next(); // return 9
|
||||
bSTIterator.hasNext(); // return True
|
||||
bSTIterator.next(); // return 15
|
||||
bSTIterator.hasNext(); // return True
|
||||
bSTIterator.next(); // return 20
|
||||
bSTIterator.hasNext(); // return False
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
|
||||
<li><code>0 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li>At most <code>10<sup>5</sup></code> calls will be made to <code>hasNext</code>, and <code>next</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Could you implement <code>next()</code> and <code>hasNext()</code> to run in average <code>O(1)</code> time and use <code>O(h)</code> memory, where <code>h</code> is the height of the tree?</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>A <strong>path</strong> in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence <strong>at most once</strong>. Note that the path does not need to pass through the root.</p>
|
||||
|
||||
<p>The <strong>path sum</strong> of a path is the sum of the node's values in the path.</p>
|
||||
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the maximum <strong>path sum</strong> of any <strong>non-empty</strong> path</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg" style="width: 322px; height: 182px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [-10,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> 42
|
||||
<strong>Explanation:</strong> The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 3 * 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>Given the <code>root</code> of a binary tree, flatten the tree into a "linked list":</p>
|
||||
|
||||
<ul>
|
||||
<li>The "linked list" should use the same <code>TreeNode</code> class where the <code>right</code> child pointer points to the next node in the list and the <code>left</code> child pointer is always <code>null</code>.</li>
|
||||
<li>The "linked list" should be in the same order as a <a href="https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR" target="_blank"><strong>pre-order</strong><strong> traversal</strong></a> of the binary tree.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg" style="width: 500px; height: 226px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,5,3,4,null,6]
|
||||
<strong>Output:</strong> [1,null,2,null,3,null,4,null,5,null,6]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [0]
|
||||
<strong>Output:</strong> [0]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Can you flatten the tree in-place (with <code>O(1)</code> extra space)?
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the inorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 125px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3]
|
||||
<strong>Output:</strong> [1,3,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the preorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 125px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3]
|
||||
<strong>Output:</strong> [1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given the <code>root</code> of a binary tree, imagine yourself standing on the <strong>right side</strong> of it, return <em>the values of the nodes you can see ordered from top to bottom</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/14/tree.jpg" style="width: 401px; height: 301px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,null,5,null,4]
|
||||
<strong>Output:</strong> [1,3,4]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,3]
|
||||
<strong>Output:</strong> [1,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the postorder traversal of its nodes' values</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/pre1.jpg" style="width: 127px; height: 200px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2,3]
|
||||
<strong>Output:</strong> [3,2,1]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of the nodes in the tree is in the range <code>[0, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the bottom-up level order traversal of its nodes' values</em>. (i.e., from left to right, level by level from leaf to root).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> [[15,7],[9,20],[3]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the level order traversal of its nodes' values</em>. (i.e., from left to right, level by level).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> [[3],[9,20],[15,7]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.</p>
|
||||
|
||||
<p>Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.</p>
|
||||
|
||||
<p><strong>Clarification:</strong> The input/output format is the same as <a href="/faq/#binary-tree" target="_blank">how LeetCode serializes a binary tree</a>. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/serdeser.jpg" style="width: 442px; height: 324px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,null,null,4,5]
|
||||
<strong>Output:</strong> [1,2,3,null,null,4,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>all root-to-leaf paths in <strong>any order</strong></em>.</p>
|
||||
|
||||
<p>A <strong>leaf</strong> is a node with no children.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/12/paths-tree.jpg" style="width: 207px; height: 293px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2,3,null,5]
|
||||
<strong>Output:</strong> ["1->2->5","1->3"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> ["1"]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[1, 100]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,26 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>its maximum depth</em>.</p>
|
||||
|
||||
<p>A binary tree's <strong>maximum depth</strong> is the number of nodes along the longest path from the root node down to the farthest leaf node.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg" style="width: 400px; height: 277px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> 3
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,null,2]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,28 @@
|
||||
<p>Given a binary tree, find its minimum depth.</p>
|
||||
|
||||
<p>The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.</p>
|
||||
|
||||
<p><strong>Note:</strong> A leaf is a node with no children.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg" style="width: 432px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> 2
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [2,null,3,null,4,null,5,null,6]
|
||||
<strong>Output:</strong> 5
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 10<sup>5</sup>]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p>
|
||||
|
||||
<p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1,2], p = 1, q = 2
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
|
||||
<li><code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code></li>
|
||||
<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
|
||||
<li><code>p != q</code></li>
|
||||
<li><code>p</code> and <code>q</code> will exist in the tree.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Given the <code>root</code> of a binary tree, return <em>the zigzag level order traversal of its nodes' values</em>. (i.e., from left to right, then right to left for the next level and alternate between).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [3,9,20,null,null,15,7]
|
||||
<strong>Output:</strong> [[3],[20,9],[15,7]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = [1]
|
||||
<strong>Output:</strong> [[1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> root = []
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>Given a 2D matrix <code>matrix</code>, handle multiple queries of the following type:</p>
|
||||
|
||||
<ul>
|
||||
<li>Calculate the <strong>sum</strong> of the elements of <code>matrix</code> inside the rectangle defined by its <strong>upper left corner</strong> <code>(row1, col1)</code> and <strong>lower right corner</strong> <code>(row2, col2)</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Implement the NumMatrix class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>NumMatrix(int[][] matrix)</code> Initializes the object with the integer matrix <code>matrix</code>.</li>
|
||||
<li><code>int sumRegion(int row1, int col1, int row2, int col2)</code> Returns the <strong>sum</strong> of the elements of <code>matrix</code> inside the rectangle defined by its <strong>upper left corner</strong> <code>(row1, col1)</code> and <strong>lower right corner</strong> <code>(row2, col2)</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/sum-grid.jpg" style="width: 415px; height: 415px;" />
|
||||
<pre>
|
||||
<strong>Input</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>Output</strong>
|
||||
[null, 8, 11, 12]
|
||||
|
||||
<strong>Explanation</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 (i.e sum of the red rectangle)
|
||||
numMatrix.sumRegion(1, 1, 2, 2); // return 11 (i.e sum of the green rectangle)
|
||||
numMatrix.sumRegion(1, 2, 2, 4); // return 12 (i.e sum of the blue rectangle)
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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></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>At most <code>10<sup>4</sup></code> calls will be made to <code>sumRegion</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes (0-59). Each LED represents a zero or one, with the least significant bit on the right.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, the below binary watch reads <code>"4:51"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2021/04/08/binarywatch.jpg" style="width: 500px; height: 500px;" /></p>
|
||||
|
||||
<p>Given an integer <code>turnedOn</code> which represents the number of LEDs that are currently on, return <em>all possible times the watch could represent</em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The hour must not contain a leading zero.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"01:00"</code> is not valid. It should be <code>"1:00"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The minute must be consist of two digits and may contain a leading zero.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, <code>"10:2"</code> is not valid. It should be <code>"10:02"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> turnedOn = 1
|
||||
<strong>Output:</strong> ["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> turnedOn = 9
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= turnedOn <= 10</code></li>
|
||||
</ul>
|
||||
18
算法题（国内版）/problem (English)/二进制求和(English) [add-binary].html
Normal file
18
算法题（国内版）/problem (English)/二进制求和(English) [add-binary].html
Normal file
@@ -0,0 +1,18 @@
|
||||
<p>Given two binary strings <code>a</code> and <code>b</code>, return <em>their sum as a binary string</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> a = "11", b = "1"
|
||||
<strong>Output:</strong> "100"
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> a = "1010", b = "1011"
|
||||
<strong>Output:</strong> "10101"
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= a.length, b.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>a</code> and <code>b</code> consist only of <code>'0'</code> or <code>'1'</code> characters.</li>
|
||||
<li>Each string does not contain leading zeros except for the zero itself.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>Given strings <code>s1</code>, <code>s2</code>, and <code>s3</code>, find whether <code>s3</code> is formed by an <strong>interleaving</strong> of <code>s1</code> and <code>s2</code>.</p>
|
||||
|
||||
<p>An <strong>interleaving</strong> of two strings <code>s</code> and <code>t</code> is a configuration where they are divided into <strong>non-empty</strong> substrings such that:</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>The <strong>interleaving</strong> is <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> or <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>Note:</strong> <code>a + b</code> is the concatenation of strings <code>a</code> and <code>b</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/02/interleave.jpg" style="width: 561px; height: 203px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s1 = "", s2 = "", s3 = ""
|
||||
<strong>Output:</strong> true
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>, and <code>s3</code> consist of lowercase English letters.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Could you solve it using only <code>O(s2.length)</code> additional memory space?</p>
|
||||
@@ -0,0 +1,66 @@
|
||||
<p>Table: <code>Customers</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| id | int |
|
||||
| name | varchar |
|
||||
+-------------+---------+
|
||||
id is the primary key column for this table.
|
||||
Each row of this table indicates the ID and name of a customer.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Table: <code>Orders</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+------+
|
||||
| Column Name | Type |
|
||||
+-------------+------+
|
||||
| id | int |
|
||||
| customerId | int |
|
||||
+-------------+------+
|
||||
id is the primary key column for this table.
|
||||
customerId is a foreign key of the ID from the Customers table.
|
||||
Each row of this table indicates the ID of an order and the ID of the customer who ordered it.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to report all customers who never order anything.</p>
|
||||
|
||||
<p>Return the result table in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Customers table:
|
||||
+----+-------+
|
||||
| id | name |
|
||||
+----+-------+
|
||||
| 1 | Joe |
|
||||
| 2 | Henry |
|
||||
| 3 | Sam |
|
||||
| 4 | Max |
|
||||
+----+-------+
|
||||
Orders table:
|
||||
+----+------------+
|
||||
| id | customerId |
|
||||
+----+------------+
|
||||
| 1 | 3 |
|
||||
| 2 | 1 |
|
||||
+----+------------+
|
||||
<strong>Output:</strong>
|
||||
+-----------+
|
||||
| Customers |
|
||||
+-----------+
|
||||
| Henry |
|
||||
| Max |
|
||||
+-----------+
|
||||
</pre>
|
||||
@@ -0,0 +1,29 @@
|
||||
<p>Given two integer arrays <code>inorder</code> and <code>postorder</code> where <code>inorder</code> is the inorder traversal of a binary tree and <code>postorder</code> is the postorder traversal of the same tree, construct and return <em>the binary tree</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
|
||||
<strong>Output:</strong> [3,9,20,null,null,15,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> inorder = [-1], postorder = [-1]
|
||||
<strong>Output:</strong> [-1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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> and <code>postorder</code> consist of <strong>unique</strong> values.</li>
|
||||
<li>Each value of <code>postorder</code> also appears in <code>inorder</code>.</li>
|
||||
<li><code>inorder</code> is <strong>guaranteed</strong> to be the inorder traversal of the tree.</li>
|
||||
<li><code>postorder</code> is <strong>guaranteed</strong> to be the postorder traversal of the tree.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,29 @@
|
||||
<p>Given two integer arrays <code>preorder</code> and <code>inorder</code> where <code>preorder</code> is the preorder traversal of a binary tree and <code>inorder</code> is the inorder traversal of the same tree, construct and return <em>the binary tree</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" style="width: 277px; height: 302px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
|
||||
<strong>Output:</strong> [3,9,20,null,null,15,7]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> preorder = [-1], inorder = [-1]
|
||||
<strong>Output:</strong> [-1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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> and <code>inorder</code> consist of <strong>unique</strong> values.</li>
|
||||
<li>Each value of <code>inorder</code> also appears in <code>preorder</code>.</li>
|
||||
<li><code>preorder</code> is <strong>guaranteed</strong> to be the preorder traversal of the tree.</li>
|
||||
<li><code>inorder</code> is <strong>guaranteed</strong> to be the inorder traversal of the tree.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the <a href="http://en.wikipedia.org/wiki/Hamming_weight" target="_blank">Hamming weight</a>).</p>
|
||||
|
||||
<p><strong>Note:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.</li>
|
||||
<li>In Java, the compiler represents the signed integers using <a href="https://en.wikipedia.org/wiki/Two%27s_complement" target="_blank">2's complement notation</a>. Therefore, in <strong>Example 3</strong>, the input represents the signed integer. <code>-3</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 00000000000000000000000000001011
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The input binary string <strong>00000000000000000000000000001011</strong> has a total of three '1' bits.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 00000000000000000000000010000000
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The input binary string <strong>00000000000000000000000010000000</strong> has a total of one '1' bit.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 11111111111111111111111111111101
|
||||
<strong>Output:</strong> 31
|
||||
<strong>Explanation:</strong> The input binary string <strong>11111111111111111111111111111101</strong> has a total of thirty one '1' bits.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The input must be a <strong>binary string</strong> of length <code>32</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> If this function is called many times, how would you optimize it?
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>You are given a 2D array of integers <code>envelopes</code> where <code>envelopes[i] = [w<sub>i</sub>, h<sub>i</sub>]</code> represents the width and the height of an envelope.</p>
|
||||
|
||||
<p>One envelope can fit into another if and only if both the width and height of one envelope are greater than the other envelope's width and height.</p>
|
||||
|
||||
<p>Return <em>the maximum number of envelopes you can Russian doll (i.e., put one inside the other)</em>.</p>
|
||||
|
||||
<p><strong>Note:</strong> You cannot rotate an envelope.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> envelopes = [[5,4],[6,4],[6,7],[2,3]]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The maximum number of envelopes you can Russian doll is <code>3</code> ([2,3] => [5,4] => [6,7]).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> envelopes = [[1,1],[1,1],[1,1]]
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>
|
||||
62
算法题（国内版）/problem (English)/克隆图(English) [clone-graph].html
Normal file
62
算法题（国内版）/problem (English)/克隆图(English) [clone-graph].html
Normal file
@@ -0,0 +1,62 @@
|
||||
<p>Given a reference of a node in a <strong><a href="https://en.wikipedia.org/wiki/Connectivity_(graph_theory)#Connected_graph" target="_blank">connected</a></strong> undirected graph.</p>
|
||||
|
||||
<p>Return a <a href="https://en.wikipedia.org/wiki/Object_copying#Deep_copy" target="_blank"><strong>deep copy</strong></a> (clone) of the graph.</p>
|
||||
|
||||
<p>Each node in the graph contains a value (<code>int</code>) and a list (<code>List[Node]</code>) of its neighbors.</p>
|
||||
|
||||
<pre>
|
||||
class Node {
|
||||
public int val;
|
||||
public List<Node> neighbors;
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>Test case format:</strong></p>
|
||||
|
||||
<p>For simplicity, each node's value is the same as the node's index (1-indexed). For example, the first node with <code>val == 1</code>, the second node with <code>val == 2</code>, and so on. The graph is represented in the test case using an adjacency list.</p>
|
||||
|
||||
<p><b>An adjacency list</b> is a collection of unordered <b>lists</b> used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.</p>
|
||||
|
||||
<p>The given node will always be the first node with <code>val = 1</code>. You must return the <strong>copy of the given node</strong> as a reference to the cloned graph.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2019/11/04/133_clone_graph_question.png" style="width: 454px; height: 500px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> adjList = [[2,4],[1,3],[2,4],[1,3]]
|
||||
<strong>Output:</strong> [[2,4],[1,3],[2,4],[1,3]]
|
||||
<strong>Explanation:</strong> There are 4 nodes in the graph.
|
||||
1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
|
||||
2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
|
||||
3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
|
||||
4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/01/07/graph.png" style="width: 163px; height: 148px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> adjList = [[]]
|
||||
<strong>Output:</strong> [[]]
|
||||
<strong>Explanation:</strong> Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> adjList = []
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> This an empty graph, it does not have any nodes.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the graph is in the range <code>[0, 100]</code>.</li>
|
||||
<li><code>1 <= Node.val <= 100</code></li>
|
||||
<li><code>Node.val</code> is unique for each node.</li>
|
||||
<li>There are no repeated edges and no self-loops in the graph.</li>
|
||||
<li>The Graph is connected and all nodes can be visited starting from the given node.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>Given a collection of numbers, <code>nums</code>, that might contain duplicates, return <em>all possible unique permutations <strong>in any order</strong>.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,2]
|
||||
<strong>Output:</strong>
|
||||
[[1,1,2],
|
||||
[1,2,1],
|
||||
[2,1,1]]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 8</code></li>
|
||||
<li><code>-10 <= nums[i] <= 10</code></li>
|
||||
</ul>
|
||||
21
算法题（国内版）/problem (English)/全排列(English) [permutations].html
Normal file
21
算法题（国内版）/problem (English)/全排列(English) [permutations].html
Normal file
@@ -0,0 +1,21 @@
|
||||
<p>Given an array <code>nums</code> of distinct integers, return <em>all the possible permutations</em>. You can return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [0,1]
|
||||
<strong>Output:</strong> [[0,1],[1,0]]
|
||||
</pre><p><strong>Example 3:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [1]
|
||||
<strong>Output:</strong> [[1]]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 6</code></li>
|
||||
<li><code>-10 <= nums[i] <= 10</code></li>
|
||||
<li>All the integers of <code>nums</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given a string <code>s</code>, partition <code>s</code> such that every substring of the partition is a palindrome.</p>
|
||||
|
||||
<p>Return <em>the minimum cuts needed</em> for a palindrome partitioning of <code>s</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "aab"
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The palindrome partitioning ["aa","b"] could be produced using 1 cut.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "a"
|
||||
<strong>Output:</strong> 0
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ab"
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 2000</code></li>
|
||||
<li><code>s</code> consists of lowercase English letters only.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,19 @@
|
||||
<p>Given a string <code>s</code>, partition <code>s</code> such that every substring of the partition is a <strong>palindrome</strong>. Return all possible palindrome partitioning of <code>s</code>.</p>
|
||||
|
||||
<p>A <strong>palindrome</strong> string is a string that reads the same backward as forward.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> s = "aab"
|
||||
<strong>Output:</strong> [["a","a","b"],["aa","b"]]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> s = "a"
|
||||
<strong>Output:</strong> [["a"]]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 16</code></li>
|
||||
<li><code>s</code> contains only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Given an array <code>nums</code> which consists of non-negative integers and an integer <code>m</code>, you can split the array into <code>m</code> non-empty continuous subarrays.</p>
|
||||
|
||||
<p>Write an algorithm to minimize the largest sum among these <code>m</code> subarrays.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [7,2,5,10,8], m = 2
|
||||
<strong>Output:</strong> 18
|
||||
<strong>Explanation:</strong>
|
||||
There are four ways to split nums into two subarrays.
|
||||
The best way is to split it into [7,2,5] and [10,8],
|
||||
where the largest sum among the two subarrays is only 18.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,5], m = 2
|
||||
<strong>Output:</strong> 9
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,4], m = 3
|
||||
<strong>Output:</strong> 4
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>
|
||||
37
算法题（国内版）/problem (English)/分发糖果(English) [candy].html
Normal file
37
算法题（国内版）/problem (English)/分发糖果(English) [candy].html
Normal file
@@ -0,0 +1,37 @@
|
||||
<p>There are <code>n</code> children standing in a line. Each child is assigned a rating value given in the integer array <code>ratings</code>.</p>
|
||||
|
||||
<p>You are giving candies to these children subjected to the following requirements:</p>
|
||||
|
||||
<ul>
|
||||
<li>Each child must have at least one candy.</li>
|
||||
<li>Children with a higher rating get more candies than their neighbors.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the minimum number of candies you need to have to distribute the candies to the children</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> ratings = [1,0,2]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> You can allocate to the first, second and third child with 2, 1, 2 candies respectively.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> ratings = [1,2,2]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> You can allocate to the first, second and third child with 1, 2, 1 candies respectively.
|
||||
The third child gets 1 candy because it satisfies the above two conditions.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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,37 @@
|
||||
<p>Given two integers representing the <code>numerator</code> and <code>denominator</code> of a fraction, return <em>the fraction in string format</em>.</p>
|
||||
|
||||
<p>If the fractional part is repeating, enclose the repeating part in parentheses.</p>
|
||||
|
||||
<p>If multiple answers are possible, return <strong>any of them</strong>.</p>
|
||||
|
||||
<p>It is <strong>guaranteed</strong> that the length of the answer string is less than <code>10<sup>4</sup></code> for all the given inputs.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numerator = 1, denominator = 2
|
||||
<strong>Output:</strong> "0.5"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numerator = 2, denominator = 1
|
||||
<strong>Output:</strong> "2"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numerator = 4, denominator = 333
|
||||
<strong>Output:</strong> "0.(012)"
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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 (English)/分数排名(English) [rank-scores].html
Normal file
55
算法题（国内版）/problem (English)/分数排名(English) [rank-scores].html
Normal file
@@ -0,0 +1,55 @@
|
||||
<p>Table: <code>Scores</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| id | int |
|
||||
| score | decimal |
|
||||
+-------------+---------+
|
||||
id is the primary key for this table.
|
||||
Each row of this table contains the score of a game. Score is a floating point value with two decimal places.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to rank the scores. The ranking should be calculated according to the following rules:</p>
|
||||
|
||||
<ul>
|
||||
<li>The scores should be ranked from the highest to the lowest.</li>
|
||||
<li>If there is a tie between two scores, both should have the same ranking.</li>
|
||||
<li>After a tie, the next ranking number should be the next consecutive integer value. In other words, there should be no holes between ranks.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return the result table ordered by <code>score</code> in descending order.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Scores table:
|
||||
+----+-------+
|
||||
| id | score |
|
||||
+----+-------+
|
||||
| 1 | 3.50 |
|
||||
| 2 | 3.65 |
|
||||
| 3 | 4.00 |
|
||||
| 4 | 3.85 |
|
||||
| 5 | 4.00 |
|
||||
| 6 | 3.65 |
|
||||
+----+-------+
|
||||
<strong>Output:</strong>
|
||||
+-------+------+
|
||||
| score | rank |
|
||||
+-------+------+
|
||||
| 4.00 | 1 |
|
||||
| 4.00 | 1 |
|
||||
| 3.85 | 2 |
|
||||
| 3.65 | 3 |
|
||||
| 3.65 | 3 |
|
||||
| 3.50 | 4 |
|
||||
+-------+------+
|
||||
</pre>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>Given the <code>head</code> of a linked list and a value <code>x</code>, partition it such that all nodes <strong>less than</strong> <code>x</code> come before nodes <strong>greater than or equal</strong> to <code>x</code>.</p>
|
||||
|
||||
<p>You should <strong>preserve</strong> the original relative order of the nodes in each of the two partitions.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/partition.jpg" style="width: 662px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,4,3,2,5,2], x = 3
|
||||
<strong>Output:</strong> [1,2,2,4,3,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [2,1], x = 2
|
||||
<strong>Output:</strong> [1,2]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the list is in the range <code>[0, 200]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li><code>-200 <= x <= 200</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,25 @@
|
||||
<p>Given the <code>head</code> of a sorted linked list, <em>delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg" style="width: 500px; height: 142px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,3,4,4,5]
|
||||
<strong>Output:</strong> [1,2,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg" style="width: 500px; height: 205px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,1,1,2,3]
|
||||
<strong>Output:</strong> [2,3]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,25 @@
|
||||
<p>Given the <code>head</code> of a sorted linked list, <em>delete all duplicates such that each element appears only once</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/list1.jpg" style="width: 302px; height: 242px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,1,2]
|
||||
<strong>Output:</strong> [1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/list2.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,1,2,3,3]
|
||||
<strong>Output:</strong> [1,2,3]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,34 @@
|
||||
<p>Given a string <code>s</code> that contains parentheses and letters, remove the minimum number of invalid parentheses to make the input string valid.</p>
|
||||
|
||||
<p>Return <em>all the possible results</em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "()())()"
|
||||
<strong>Output:</strong> ["(())()","()()()"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "(a)())()"
|
||||
<strong>Output:</strong> ["(a())()","(a)()()"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = ")("
|
||||
<strong>Output:</strong> [""]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 25</code></li>
|
||||
<li><code>s</code> consists of lowercase English letters and parentheses <code>'('</code> and <code>')'</code>.</li>
|
||||
<li>There will be at most <code>20</code> parentheses in <code>s</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>Given an integer array <code>nums</code> sorted in <strong>non-decreasing order</strong>, remove some duplicates <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank"><strong>in-place</strong></a> such that each unique element appears <strong>at most twice</strong>. The <strong>relative order</strong> of the elements should be kept the <strong>same</strong>.</p>
|
||||
|
||||
<p>Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the <strong>first part</strong> of the array <code>nums</code>. More formally, if there are <code>k</code> elements after removing the duplicates, then the first <code>k</code> elements of <code>nums</code> should hold the final result. It does not matter what you leave beyond the first <code>k</code> elements.</p>
|
||||
|
||||
<p>Return <code>k</code><em> after placing the final result in the first </em><code>k</code><em> slots of </em><code>nums</code>.</p>
|
||||
|
||||
<p>Do <strong>not</strong> allocate extra space for another array. You must do this by <strong>modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a></strong> with O(1) extra memory.</p>
|
||||
|
||||
<p><strong>Custom Judge:</strong></p>
|
||||
|
||||
<p>The judge will test your solution with the following code:</p>
|
||||
|
||||
<pre>
|
||||
int[] nums = [...]; // Input array
|
||||
int[] expectedNums = [...]; // The expected answer with correct length
|
||||
|
||||
int k = removeDuplicates(nums); // Calls your implementation
|
||||
|
||||
assert k == expectedNums.length;
|
||||
for (int i = 0; i < k; i++) {
|
||||
assert nums[i] == expectedNums[i];
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>If all assertions pass, then your solution will be <strong>accepted</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,1,2,2,3]
|
||||
<strong>Output:</strong> 5, nums = [1,1,2,2,3,_]
|
||||
<strong>Explanation:</strong> Your function should return k = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
|
||||
It does not matter what you leave beyond the returned k (hence they are underscores).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,0,1,1,1,1,2,3,3]
|
||||
<strong>Output:</strong> 7, nums = [0,0,1,1,2,3,3,_,_]
|
||||
<strong>Explanation:</strong> Your function should return k = 7, with the first seven elements of nums being 0, 0, 1, 1, 2, 3 and 3 respectively.
|
||||
It does not matter what you leave beyond the returned k (hence they are underscores).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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> is sorted in <strong>non-decreasing</strong> order.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>Given an integer array <code>nums</code> sorted in <strong>non-decreasing order</strong>, remove the duplicates <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank"><strong>in-place</strong></a> such that each unique element appears only <strong>once</strong>. The <strong>relative order</strong> of the elements should be kept the <strong>same</strong>.</p>
|
||||
|
||||
<p>Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the <strong>first part</strong> of the array <code>nums</code>. More formally, if there are <code>k</code> elements after removing the duplicates, then the first <code>k</code> elements of <code>nums</code> should hold the final result. It does not matter what you leave beyond the first <code>k</code> elements.</p>
|
||||
|
||||
<p>Return <code>k</code><em> after placing the final result in the first </em><code>k</code><em> slots of </em><code>nums</code>.</p>
|
||||
|
||||
<p>Do <strong>not</strong> allocate extra space for another array. You must do this by <strong>modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a></strong> with O(1) extra memory.</p>
|
||||
|
||||
<p><strong>Custom Judge:</strong></p>
|
||||
|
||||
<p>The judge will test your solution with the following code:</p>
|
||||
|
||||
<pre>
|
||||
int[] nums = [...]; // Input array
|
||||
int[] expectedNums = [...]; // The expected answer with correct length
|
||||
|
||||
int k = removeDuplicates(nums); // Calls your implementation
|
||||
|
||||
assert k == expectedNums.length;
|
||||
for (int i = 0; i < k; i++) {
|
||||
assert nums[i] == expectedNums[i];
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>If all assertions pass, then your solution will be <strong>accepted</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,2]
|
||||
<strong>Output:</strong> 2, nums = [1,2,_]
|
||||
<strong>Explanation:</strong> Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.
|
||||
It does not matter what you leave beyond the returned k (hence they are underscores).
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0,0,1,1,1,2,2,3,3,4]
|
||||
<strong>Output:</strong> 5, nums = [0,1,2,3,4,_,_,_,_,_]
|
||||
<strong>Explanation:</strong> Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.
|
||||
It does not matter what you leave beyond the returned k (hence they are underscores).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>nums</code> is sorted in <strong>non-decreasing</strong> order.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>Table: <code>Person</code></p>
|
||||
|
||||
<pre>
|
||||
+-------------+---------+
|
||||
| Column Name | Type |
|
||||
+-------------+---------+
|
||||
| id | int |
|
||||
| email | varchar |
|
||||
+-------------+---------+
|
||||
id is the primary key column for this table.
|
||||
Each row of this table contains an email. The emails will not contain uppercase letters.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p>Write an SQL query to <strong>delete</strong> all the duplicate emails, keeping only one unique email with the smallest <code>id</code>. Note that you are supposed to write a <code>DELETE</code> statement and not a <code>SELECT</code> one.</p>
|
||||
|
||||
<p>Return the result table in <strong>any order</strong>.</p>
|
||||
|
||||
<p>The query result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
Person table:
|
||||
+----+------------------+
|
||||
| id | email |
|
||||
+----+------------------+
|
||||
| 1 | john@example.com |
|
||||
| 2 | bob@example.com |
|
||||
| 3 | john@example.com |
|
||||
+----+------------------+
|
||||
<strong>Output:</strong>
|
||||
+----+------------------+
|
||||
| id | email |
|
||||
+----+------------------+
|
||||
| 1 | john@example.com |
|
||||
| 2 | bob@example.com |
|
||||
+----+------------------+
|
||||
<strong>Explanation:</strong> john@example.com is repeated two times. We keep the row with the smallest Id = 1.
|
||||
</pre>
|
||||
@@ -0,0 +1,30 @@
|
||||
<p>Write a function to <strong>delete a node</strong> in a singly-linked list. You will <strong>not</strong> be given access to the <code>head</code> of the list, instead you will be given access to <strong>the node to be deleted</strong> directly.</p>
|
||||
|
||||
<p>It is <strong>guaranteed</strong> that the node to be deleted is <strong>not a tail node</strong> in the list.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node1.jpg" style="width: 300px; height: 215px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [4,5,1,9], node = 5
|
||||
<strong>Output:</strong> [4,1,9]
|
||||
<strong>Explanation: </strong>You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node2.jpg" style="width: 300px; height: 236px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [4,5,1,9], node = 1
|
||||
<strong>Output:</strong> [4,5,9]
|
||||
<strong>Explanation: </strong>You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of the nodes in the given list is in the range <code>[2, 1000]</code>.</li>
|
||||
<li><code>-1000 <= Node.val <= 1000</code></li>
|
||||
<li>The value of each node in the list is <strong>unique</strong>.</li>
|
||||
<li>The <code>node</code> to be deleted is <strong>in the list</strong> and is <strong>not a tail</strong> node</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>Given the <code>head</code> of a linked list, remove the <code>n<sup>th</sup></code> node from the end of the list and return its head.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/remove_ex1.jpg" style="width: 542px; height: 222px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2,3,4,5], n = 2
|
||||
<strong>Output:</strong> [1,2,3,5]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1], n = 1
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> head = [1,2], n = 1
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>The number of nodes in the list is <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>Follow up:</strong> Could you do this in one pass?</p>
|
||||
@@ -0,0 +1,23 @@
|
||||
<p>Given two strings <code>s</code> and <code>t</code>, return <code>true</code><em> if </em><code>s</code><em> is a <strong>subsequence</strong> of </em><code>t</code><em>, or </em><code>false</code><em> otherwise</em>.</p>
|
||||
|
||||
<p>A <strong>subsequence</strong> of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., <code>"ace"</code> is a subsequence of <code>"<u>a</u>b<u>c</u>d<u>e</u>"</code> while <code>"aec"</code> is not).</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> s = "abc", t = "ahbgdc"
|
||||
<strong>Output:</strong> true
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> s = "axc", t = "ahbgdc"
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= s.length <= 100</code></li>
|
||||
<li><code>0 <= t.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<strong>Follow up:</strong> Suppose there are lots of incoming <code>s</code>, say <code>s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub></code> where <code>k >= 10<sup>9</sup></code>, and you want to check one by one to see if <code>t</code> has its subsequence. In this scenario, how would you change your code?
|
||||
@@ -0,0 +1,21 @@
|
||||
<p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the</em> <code>k</code> <em>most frequent elements</em>. You may return the answer in <strong>any order</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [1,1,1,2,2,3], k = 2
|
||||
<strong>Output:</strong> [1,2]
|
||||
</pre><p><strong>Example 2:</strong></p>
|
||||
<pre><strong>Input:</strong> nums = [1], k = 1
|
||||
<strong>Output:</strong> [1]
|
||||
</pre>
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>k</code> is in the range <code>[1, the number of unique elements in the array]</code>.</li>
|
||||
<li>It is <strong>guaranteed</strong> that the answer is <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Follow up:</strong> Your algorithm's time complexity must be better than <code>O(n log n)</code>, where n is the array's size.</p>
|
||||
43
算法题（国内版）/problem (English)/加一(English) [plus-one].html
Normal file
43
算法题（国内版）/problem (English)/加一(English) [plus-one].html
Normal file
@@ -0,0 +1,43 @@
|
||||
<p>You are given a <strong>large integer</strong> represented as an integer array <code>digits</code>, where each <code>digits[i]</code> is the <code>i<sup>th</sup></code> digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading <code>0</code>'s.</p>
|
||||
|
||||
<p>Increment the large integer by one and return <em>the resulting array of digits</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> digits = [1,2,3]
|
||||
<strong>Output:</strong> [1,2,4]
|
||||
<strong>Explanation:</strong> The array represents the integer 123.
|
||||
Incrementing by one gives 123 + 1 = 124.
|
||||
Thus, the result should be [1,2,4].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> digits = [4,3,2,1]
|
||||
<strong>Output:</strong> [4,3,2,2]
|
||||
<strong>Explanation:</strong> The array represents the integer 4321.
|
||||
Incrementing by one gives 4321 + 1 = 4322.
|
||||
Thus, the result should be [4,3,2,2].
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> digits = [9]
|
||||
<strong>Output:</strong> [1,0]
|
||||
<strong>Explanation:</strong> The array represents the integer 9.
|
||||
Incrementing by one gives 9 + 1 = 10.
|
||||
Thus, the result should be [1,0].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= digits.length <= 100</code></li>
|
||||
<li><code>0 <= digits[i] <= 9</code></li>
|
||||
<li><code>digits</code> does not contain any leading <code>0</code>'s.</li>
|
||||
</ul>
|
||||
44
算法题（国内版）/problem (English)/加油站(English) [gas-station].html
Normal file
44
算法题（国内版）/problem (English)/加油站(English) [gas-station].html
Normal file
@@ -0,0 +1,44 @@
|
||||
<p>There are <code>n</code> gas stations along a circular route, where the amount of gas at the <code>i<sup>th</sup></code> station is <code>gas[i]</code>.</p>
|
||||
|
||||
<p>You have a car with an unlimited gas tank and it costs <code>cost[i]</code> of gas to travel from the <code>i<sup>th</sup></code> station to its next <code>(i + 1)<sup>th</sup></code> station. You begin the journey with an empty tank at one of the gas stations.</p>
|
||||
|
||||
<p>Given two integer arrays <code>gas</code> and <code>cost</code>, return <em>the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return</em> <code>-1</code>. If there exists a solution, it is <strong>guaranteed</strong> to be <strong>unique</strong></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> gas = [1,2,3,4,5], cost = [3,4,5,1,2]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong>
|
||||
Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
|
||||
Travel to station 4. Your tank = 4 - 1 + 5 = 8
|
||||
Travel to station 0. Your tank = 8 - 2 + 1 = 7
|
||||
Travel to station 1. Your tank = 7 - 3 + 2 = 6
|
||||
Travel to station 2. Your tank = 6 - 4 + 3 = 5
|
||||
Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.
|
||||
Therefore, return 3 as the starting index.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> gas = [2,3,4], cost = [3,4,3]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong>
|
||||
You can't start at station 0 or 1, as there is not enough gas to travel to the next station.
|
||||
Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
|
||||
Travel to station 0. Your tank = 4 - 3 + 2 = 3
|
||||
Travel to station 1. Your tank = 3 - 3 + 3 = 3
|
||||
You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.
|
||||
Therefore, you can't travel around the circuit once no matter where you start.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == gas.length == cost.length</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,39 @@
|
||||
<p>Given an integer array <code>nums</code>, handle multiple queries of the following type:</p>
|
||||
|
||||
<ol>
|
||||
<li>Calculate the <strong>sum</strong> of the elements of <code>nums</code> between indices <code>left</code> and <code>right</code> <strong>inclusive</strong> where <code>left <= right</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>Implement the <code>NumArray</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>NumArray(int[] nums)</code> Initializes the object with the integer array <code>nums</code>.</li>
|
||||
<li><code>int sumRange(int left, int right)</code> Returns the <strong>sum</strong> of the elements of <code>nums</code> between indices <code>left</code> and <code>right</code> <strong>inclusive</strong> (i.e. <code>nums[left] + nums[left + 1] + ... + nums[right]</code>).</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["NumArray", "sumRange", "sumRange", "sumRange"]
|
||||
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
|
||||
<strong>Output</strong>
|
||||
[null, 1, -1, -3]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
|
||||
numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1
|
||||
numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1
|
||||
numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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 <= left <= right < nums.length</code></li>
|
||||
<li>At most <code>10<sup>4</sup></code> calls will be made to <code>sumRange</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>Given an integer array <code>nums</code>, handle multiple queries of the following types:</p>
|
||||
|
||||
<ol>
|
||||
<li><strong>Update</strong> the value of an element in <code>nums</code>.</li>
|
||||
<li>Calculate the <strong>sum</strong> of the elements of <code>nums</code> between indices <code>left</code> and <code>right</code> <strong>inclusive</strong> where <code>left <= right</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p>Implement the <code>NumArray</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>NumArray(int[] nums)</code> Initializes the object with the integer array <code>nums</code>.</li>
|
||||
<li><code>void update(int index, int val)</code> <strong>Updates</strong> the value of <code>nums[index]</code> to be <code>val</code>.</li>
|
||||
<li><code>int sumRange(int left, int right)</code> Returns the <strong>sum</strong> of the elements of <code>nums</code> between indices <code>left</code> and <code>right</code> <strong>inclusive</strong> (i.e. <code>nums[left] + nums[left + 1] + ... + nums[right]</code>).</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["NumArray", "sumRange", "update", "sumRange"]
|
||||
[[[1, 3, 5]], [0, 2], [1, 2], [0, 2]]
|
||||
<strong>Output</strong>
|
||||
[null, 9, null, 8]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
NumArray numArray = new NumArray([1, 3, 5]);
|
||||
numArray.sumRange(0, 2); // return 1 + 3 + 5 = 9
|
||||
numArray.update(1, 2); // nums = [1, 2, 5]
|
||||
numArray.sumRange(0, 2); // return 1 + 2 + 5 = 8
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>At most <code>3 * 10<sup>4</sup></code> calls will be made to <code>update</code> and <code>sumRange</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,29 @@
|
||||
<p>Given an integer array <code>nums</code> and two integers <code>lower</code> and <code>upper</code>, return <em>the number of range sums that lie in</em> <code>[lower, upper]</code> <em>inclusive</em>.</p>
|
||||
|
||||
<p>Range sum <code>S(i, j)</code> is defined as the sum of the elements in <code>nums</code> between indices <code>i</code> and <code>j</code> inclusive, where <code>i <= j</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-2,5,-1], lower = -2, upper = 2
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The three ranges are: [0,0], [2,2], and [0,2] and their respective sums are: -2, -1, 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [0], lower = 0, upper = 0
|
||||
<strong>Output:</strong> 1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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>The answer is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,37 @@
|
||||
<p>Given a string <code>s</code> and a dictionary of strings <code>wordDict</code>, add spaces in <code>s</code> to construct a sentence where each word is a valid dictionary word. Return all such possible sentences in <strong>any order</strong>.</p>
|
||||
|
||||
<p><strong>Note</strong> that the same word in the dictionary may be reused multiple times in the segmentation.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "catsanddog", wordDict = ["cat","cats","and","sand","dog"]
|
||||
<strong>Output:</strong> ["cats and dog","cat sand dog"]
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "pineapplepenapple", wordDict = ["apple","pen","applepen","pine","pineapple"]
|
||||
<strong>Output:</strong> ["pine apple pen apple","pineapple pen apple","pine applepen apple"]
|
||||
<strong>Explanation:</strong> Note that you are allowed to reuse a dictionary word.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
|
||||
<strong>Output:</strong> []
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></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> and <code>wordDict[i]</code> consist of only lowercase English letters.</li>
|
||||
<li>All the strings of <code>wordDict</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
39
算法题（国内版）/problem (English)/单词拆分(English) [word-break].html
Normal file
39
算法题（国内版）/problem (English)/单词拆分(English) [word-break].html
Normal file
@@ -0,0 +1,39 @@
|
||||
<p>Given a string <code>s</code> and a dictionary of strings <code>wordDict</code>, return <code>true</code> if <code>s</code> can be segmented into a space-separated sequence of one or more dictionary words.</p>
|
||||
|
||||
<p><strong>Note</strong> that the same word in the dictionary may be reused multiple times in the segmentation.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "leetcode", wordDict = ["leet","code"]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Return true because "leetcode" can be segmented as "leet code".
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "applepenapple", wordDict = ["apple","pen"]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Return true because "applepenapple" can be segmented as "apple pen apple".
|
||||
Note that you are allowed to reuse a dictionary word.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
|
||||
<strong>Output:</strong> false
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</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> and <code>wordDict[i]</code> consist of only lowercase English letters.</li>
|
||||
<li>All the strings of <code>wordDict</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>A <strong>transformation sequence</strong> from word <code>beginWord</code> to word <code>endWord</code> using a dictionary <code>wordList</code> is a sequence of words <code>beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub></code> such that:</p>
|
||||
|
||||
<ul>
|
||||
<li>Every adjacent pair of words differs by a single letter.</li>
|
||||
<li>Every <code>s<sub>i</sub></code> for <code>1 <= i <= k</code> is in <code>wordList</code>. Note that <code>beginWord</code> does not need to be in <code>wordList</code>.</li>
|
||||
<li><code>s<sub>k</sub> == endWord</code></li>
|
||||
</ul>
|
||||
|
||||
<p>Given two words, <code>beginWord</code> and <code>endWord</code>, and a dictionary <code>wordList</code>, return <em>all the <strong>shortest transformation sequences</strong> from</em> <code>beginWord</code> <em>to</em> <code>endWord</code><em>, or an empty list if no such sequence exists. Each sequence should be returned as a list of the words </em><code>[beginWord, s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub>]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
|
||||
<strong>Output:</strong> [["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
|
||||
<strong>Explanation:</strong> There are 2 shortest transformation sequences:
|
||||
"hit" -> "hot" -> "dot" -> "dog" -> "cog"
|
||||
"hit" -> "hot" -> "lot" -> "log" -> "cog"
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> The endWord "cog" is not in wordList, therefore there is no valid transformation sequence.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= beginWord.length <= 5</code></li>
|
||||
<li><code>endWord.length == beginWord.length</code></li>
|
||||
<li><code>1 <= wordList.length <= 1000</code></li>
|
||||
<li><code>wordList[i].length == beginWord.length</code></li>
|
||||
<li><code>beginWord</code>, <code>endWord</code>, and <code>wordList[i]</code> consist of lowercase English letters.</li>
|
||||
<li><code>beginWord != endWord</code></li>
|
||||
<li>All the words in <code>wordList</code> are <strong>unique</strong>.</li>
|
||||
</ul>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user