mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-02 05:13:29 +08:00
update
This commit is contained in:
@@ -0,0 +1,45 @@
|
||||
<p>You are given an <code>m x n</code> matrix <code>grid</code> consisting of positive integers.</p>
|
||||
|
||||
<p>Perform the following operation until <code>grid</code> becomes empty:</p>
|
||||
|
||||
<ul>
|
||||
<li>Delete the element with the greatest value from each row. If multiple such elements exist, delete any of them.</li>
|
||||
<li>Add the maximum of deleted elements to the answer.</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>Note</strong> that the number of columns decreases by one after each operation.</p>
|
||||
|
||||
<p>Return <em>the answer after performing the operations described above</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/10/19/q1ex1.jpg" style="width: 600px; height: 135px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,2,4],[3,3,1]]
|
||||
<strong>Output:</strong> 8
|
||||
<strong>Explanation:</strong> The diagram above shows the removed values in each step.
|
||||
- In the first operation, we remove 4 from the first row and 3 from the second row (notice that, there are two cells with value 3 and we can remove any of them). We add 4 to the answer.
|
||||
- In the second operation, we remove 2 from the first row and 3 from the second row. We add 3 to the answer.
|
||||
- In the third operation, we remove 1 from the first row and 1 from the second row. We add 1 to the answer.
|
||||
The final answer = 4 + 3 + 1 = 8.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/10/19/q1ex2.jpg" style="width: 83px; height: 83px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[10]]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> The diagram above shows the removed values in each step.
|
||||
- In the first operation, we remove 10 from the first row. We add 10 to the answer.
|
||||
The final answer = 10.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m, n <= 50</code></li>
|
||||
<li><code>1 <= grid[i][j] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>There is an undirected graph consisting of <code>n</code> nodes numbered from <code>0</code> to <code>n - 1</code>. You are given a <strong>0-indexed</strong> integer array <code>vals</code> of length <code>n</code> where <code>vals[i]</code> denotes the value of the <code>i<sup>th</sup></code> node.</p>
|
||||
|
||||
<p>You are also given a 2D integer array <code>edges</code> where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists an <strong>undirected</strong> edge connecting nodes <code>a<sub>i</sub></code> and <code>b<sub>i.</sub></code></p>
|
||||
|
||||
<p>A <strong>star graph</strong> is a subgraph of the given graph having a center node containing <code>0</code> or more neighbors. In other words, it is a subset of edges of the given graph such that there exists a common node for all edges.</p>
|
||||
|
||||
<p>The image below shows star graphs with <code>3</code> and <code>4</code> neighbors respectively, centered at the blue node.</p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/11/07/max-star-sum-descdrawio.png" style="width: 400px; height: 179px;" />
|
||||
<p>The <strong>star sum</strong> is the sum of the values of all the nodes present in the star graph.</p>
|
||||
|
||||
<p>Given an integer <code>k</code>, return <em>the <strong>maximum star sum</strong> of a star graph containing <strong>at most</strong> </em><code>k</code><em> edges.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/11/07/max-star-sum-example1drawio.png" style="width: 300px; height: 291px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> vals = [1,2,3,4,10,-10,-20], edges = [[0,1],[1,2],[1,3],[3,4],[3,5],[3,6]], k = 2
|
||||
<strong>Output:</strong> 16
|
||||
<strong>Explanation:</strong> The above diagram represents the input graph.
|
||||
The star graph with the maximum star sum is denoted by blue. It is centered at 3 and includes its neighbors 1 and 4.
|
||||
It can be shown it is not possible to get a star graph with a sum greater than 16.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> vals = [-5], edges = [], k = 0
|
||||
<strong>Output:</strong> -5
|
||||
<strong>Explanation:</strong> There is only one possible star graph, which is node 0 itself.
|
||||
Hence, we return -5.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == vals.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= vals[i] <= 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= edges.length <= min(n * (n - 1) / 2</code><code>, 10<sup>5</sup>)</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>0 <= a<sub>i</sub>, b<sub>i</sub> <= n - 1</code></li>
|
||||
<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
|
||||
<li><code>0 <= k <= n - 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>The <strong>value</strong> of an alphanumeric string can be defined as:</p>
|
||||
|
||||
<ul>
|
||||
<li>The <strong>numeric</strong> representation of the string in base <code>10</code>, if it comprises of digits <strong>only</strong>.</li>
|
||||
<li>The <strong>length</strong> of the string, otherwise.</li>
|
||||
</ul>
|
||||
|
||||
<p>Given an array <code>strs</code> of alphanumeric strings, return <em>the <strong>maximum value</strong> of any string in </em><code>strs</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> strs = ["alic3","bob","3","4","00000"]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
- "alic3" consists of both letters and digits, so its value is its length, i.e. 5.
|
||||
- "bob" consists only of letters, so its value is also its length, i.e. 3.
|
||||
- "3" consists only of digits, so its value is its numeric equivalent, i.e. 3.
|
||||
- "4" also consists only of digits, so its value is 4.
|
||||
- "00000" consists only of digits, so its value is 0.
|
||||
Hence, the maximum value is 5, of "alic3".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> strs = ["1","01","001","0001"]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong>
|
||||
Each string in the array has value 1. Hence, we return 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= strs.length <= 100</code></li>
|
||||
<li><code>1 <= strs[i].length <= 9</code></li>
|
||||
<li><code>strs[i]</code> consists of only lowercase English letters and digits.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given an integer array <code>nums</code>. A subsequence of <code>nums</code> is called a <strong>square streak</strong> if:</p>
|
||||
|
||||
<ul>
|
||||
<li>The length of the subsequence is at least <code>2</code>, and</li>
|
||||
<li><strong>after</strong> sorting the subsequence, each element (except the first element) is the <strong>square</strong> of the previous number.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return<em> the length of the <strong>longest square streak</strong> in </em><code>nums</code><em>, or return </em><code>-1</code><em> if there is no <strong>square streak</strong>.</em></p>
|
||||
|
||||
<p>A <strong>subsequence</strong> is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4,3,6,16,8,2]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> Choose the subsequence [4,16,2]. After sorting it, it becomes [2,4,16].
|
||||
- 4 = 2 * 2.
|
||||
- 16 = 4 * 4.
|
||||
Therefore, [4,16,2] is a square streak.
|
||||
It can be shown that every subsequence of length 4 is not a square streak.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,3,5,6,7]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> There is no square streak in nums so return -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>2 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>You are given an <code>m x n</code> integer matrix <code>grid</code> and an array <code>queries</code> of size <code>k</code>.</p>
|
||||
|
||||
<p>Find an array <code>answer</code> of size <code>k</code> such that for each integer <code>queres[i]</code> you start in the <strong>top left</strong> cell of the matrix and repeat the following process:</p>
|
||||
|
||||
<ul>
|
||||
<li>If <code>queries[i]</code> is <strong>strictly</strong> greater than the value of the current cell that you are in, then you get one point if it is your first time visiting this cell, and you can move to any <strong>adjacent</strong> cell in all <code>4</code> directions: up, down, left, and right.</li>
|
||||
<li>Otherwise, you do not get any points, and you end this process.</li>
|
||||
</ul>
|
||||
|
||||
<p>After the process, <code>answer[i]</code> is the <strong>maximum</strong> number of points you can get. <strong>Note</strong> that for each query you are allowed to visit the same cell <strong>multiple</strong> times.</p>
|
||||
|
||||
<p>Return <em>the resulting array</em> <code>answer</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/10/19/yetgriddrawio.png" style="width: 571px; height: 151px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2]
|
||||
<strong>Output:</strong> [5,8,1]
|
||||
<strong>Explanation:</strong> The diagrams above show which cells we visit to get points for each query.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/10/20/yetgriddrawio-2.png" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[5,2,1],[1,1,2]], queries = [3]
|
||||
<strong>Output:</strong> [0]
|
||||
<strong>Explanation:</strong> We can not get any points because the value of the top left cell is already greater than or equal to 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>2 <= m, n <= 1000</code></li>
|
||||
<li><code>4 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>k == queries.length</code></li>
|
||||
<li><code>1 <= k <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= grid[i][j], queries[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,53 @@
|
||||
<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, of equal length <code>n</code>.</p>
|
||||
|
||||
<p>In one operation, you can swap the values of any two indices of <code>nums1</code>. The <strong>cost</strong> of this operation is the <strong>sum</strong> of the indices.</p>
|
||||
|
||||
<p>Find the <strong>minimum</strong> total cost of performing the given operation <strong>any</strong> number of times such that <code>nums1[i] != nums2[i]</code> for all <code>0 <= i <= n - 1</code> after performing all the operations.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum total cost</strong> such that </em><code>nums1</code> and <code>nums2</code><em> satisfy the above condition</em>. In case it is not possible, return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,2,3,4,5], nums2 = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong>
|
||||
One of the ways we can perform the operations is:
|
||||
- Swap values at indices 0 and 3, incurring cost = 0 + 3 = 3. Now, nums1 = [4,2,3,1,5]
|
||||
- Swap values at indices 1 and 2, incurring cost = 1 + 2 = 3. Now, nums1 = [4,3,2,1,5].
|
||||
- Swap values at indices 0 and 4, incurring cost = 0 + 4 = 4. Now, nums1 =[5,3,2,1,4].
|
||||
We can see that for each index i, nums1[i] != nums2[i]. The cost required here is 10.
|
||||
Note that there are other ways to swap values, but it can be proven that it is not possible to obtain a cost less than 10.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [2,2,2,1,3], nums2 = [1,2,2,3,3]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong>
|
||||
One of the ways we can perform the operations is:
|
||||
- Swap values at indices 2 and 3, incurring cost = 2 + 3 = 5. Now, nums1 = [2,2,1,2,3].
|
||||
- Swap values at indices 1 and 4, incurring cost = 1 + 4 = 5. Now, nums1 = [2,3,1,2,2].
|
||||
The total cost needed here is 10, which is the minimum possible.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [1,2,2], nums2 = [1,2,2]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong>
|
||||
It can be shown that it is not possible to satisfy the given conditions irrespective of the number of operations we perform.
|
||||
Hence, we return -1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums1.length == nums2.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums1[i], nums2[i] <= n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,55 @@
|
||||
<p>You are given an integer <code>n</code> representing the size of a <strong>0-indexed</strong> memory array. All memory units are initially free.</p>
|
||||
|
||||
<p>You have a memory allocator with the following functionalities:</p>
|
||||
|
||||
<ol>
|
||||
<li><strong>Allocate </strong>a block of <code>size</code> consecutive free memory units and assign it the id <code>mID</code>.</li>
|
||||
<li><strong>Free</strong> all memory units with the given id <code>mID</code>.</li>
|
||||
</ol>
|
||||
|
||||
<p><strong>Note</strong> that:</p>
|
||||
|
||||
<ul>
|
||||
<li>Multiple blocks can be allocated to the same <code>mID</code>.</li>
|
||||
<li>You should free all the memory units with <code>mID</code>, even if they were allocated in different blocks.</li>
|
||||
</ul>
|
||||
|
||||
<p>Implement the <code>Allocator</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>Allocator(int n)</code> Initializes an <code>Allocator</code> object with a memory array of size <code>n</code>.</li>
|
||||
<li><code>int allocate(int size, int mID)</code> Find the <strong>leftmost</strong> block of <code>size</code> <strong>consecutive</strong> free memory units and allocate it with the id <code>mID</code>. Return the block's first index. If such a block does not exist, return <code>-1</code>.</li>
|
||||
<li><code>int free(int mID)</code> Free all memory units with the id <code>mID</code>. Return the number of memory units you have freed.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input</strong>
|
||||
["Allocator", "allocate", "allocate", "allocate", "free", "allocate", "allocate", "allocate", "free", "allocate", "free"]
|
||||
[[10], [1, 1], [1, 2], [1, 3], [2], [3, 4], [1, 1], [1, 1], [1], [10, 2], [7]]
|
||||
<strong>Output</strong>
|
||||
[null, 0, 1, 2, 1, 3, 1, 6, 3, -1, 0]
|
||||
|
||||
<strong>Explanation</strong>
|
||||
Allocator loc = new Allocator(10); // Initialize a memory array of size 10. All memory units are initially free.
|
||||
loc.allocate(1, 1); // The leftmost block's first index is 0. The memory array becomes [<strong>1</strong>,_,_,_,_,_,_,_,_,_]. We return 0.
|
||||
loc.allocate(1, 2); // The leftmost block's first index is 1. The memory array becomes [1,<strong>2</strong>,_,_,_,_,_,_,_,_]. We return 1.
|
||||
loc.allocate(1, 3); // The leftmost block's first index is 2. The memory array becomes [1,2,<strong>3</strong>,_,_,_,_,_,_,_]. We return 2.
|
||||
loc.free(2); // Free all memory units with mID 2. The memory array becomes [1,_, 3,_,_,_,_,_,_,_]. We return 1 since there is only 1 unit with mID 2.
|
||||
loc.allocate(3, 4); // The leftmost block's first index is 3. The memory array becomes [1,_,3,<strong>4</strong>,<strong>4</strong>,<strong>4</strong>,_,_,_,_]. We return 3.
|
||||
loc.allocate(1, 1); // The leftmost block's first index is 1. The memory array becomes [1,<strong>1</strong>,3,4,4,4,_,_,_,_]. We return 1.
|
||||
loc.allocate(1, 1); // The leftmost block's first index is 6. The memory array becomes [1,1,3,4,4,4,<strong>1</strong>,_,_,_]. We return 6.
|
||||
loc.free(1); // Free all memory units with mID 1. The memory array becomes [_,_,3,4,4,4,_,_,_,_]. We return 3 since there are 3 units with mID 1.
|
||||
loc.allocate(10, 2); // We can not find any free block with 10 consecutive free memory units, so we return -1.
|
||||
loc.free(7); // Free all memory units with mID 7. The memory array remains the same since there is no memory unit with mID 7. We return 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n, size, mID <= 1000</code></li>
|
||||
<li>At most <code>1000</code> calls will be made to <code>allocate</code> and <code>free</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>stones</code> sorted in <strong>strictly increasing order</strong> representing the positions of stones in a river.</p>
|
||||
|
||||
<p>A frog, initially on the first stone, wants to travel to the last stone and then return to the first stone. However, it can jump to any stone <strong>at most once</strong>.</p>
|
||||
|
||||
<p>The <strong>length</strong> of a jump is the absolute difference between the position of the stone the frog is currently on and the position of the stone to which the frog jumps.</p>
|
||||
|
||||
<ul>
|
||||
<li>More formally, if the frog is at <code>stones[i]</code> and is jumping to <code>stones[j]</code>, the length of the jump is <code>|stones[i] - stones[j]|</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The <strong>cost</strong> of a path is the <strong>maximum length of a jump</strong> among all jumps in the path.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> cost of a path for the frog</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/11/14/example-1.png" style="width: 600px; height: 219px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> stones = [0,2,5,6,7]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The above figure represents one of the optimal paths the frog can take.
|
||||
The cost of this path is 5, which is the maximum length of a jump.
|
||||
Since it is not possible to achieve a cost of less than 5, we return it.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/11/14/example-2.png" style="width: 500px; height: 171px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> stones = [0,3,9]
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong>
|
||||
The frog can jump directly to the last stone and come back to the first stone.
|
||||
In this case, the length of each jump will be 9. The cost for the path will be max(9, 9) = 9.
|
||||
It can be shown that this is the minimum achievable cost.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= stones.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= stones[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>stones[0] == 0</code></li>
|
||||
<li><code>stones</code> is sorted in a strictly increasing order.</li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user