mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-10-18 19:46:47 +08:00
update
This commit is contained in:
@@ -0,0 +1,40 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> consisting of positive integers.</p>
|
||||
|
||||
<p>There are two types of operations that you can apply on the array <strong>any</strong> number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose <strong>two</strong> elements with <strong>equal</strong> values and <strong>delete</strong> them from the array.</li>
|
||||
<li>Choose <strong>three</strong> elements with <strong>equal</strong> values and <strong>delete</strong> them from the array.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of operations required to make the array empty, or </em><code>-1</code><em> if it is not possible</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,3,3,2,2,4,2,3,4]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> We can apply the following operations to make the array empty:
|
||||
- Apply the first operation on the elements at indices 0 and 3. The resulting array is nums = [3,3,2,4,2,3,4].
|
||||
- Apply the first operation on the elements at indices 2 and 4. The resulting array is nums = [3,3,4,3,4].
|
||||
- Apply the second operation on the elements at indices 0, 1, and 3. The resulting array is nums = [4,4].
|
||||
- Apply the first operation on the elements at indices 0 and 1. The resulting array is nums = [].
|
||||
It can be shown that we cannot make the array empty in less than 4 operations.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,1,2,2,3,3]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> It is impossible to empty the array.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>There is an undirected tree with <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>. You are given the integer <code>n</code> and a 2D integer array <code>edges</code> of length <code>n - 1</code>, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.</p>
|
||||
|
||||
<p>You are also given a <strong>0-indexed</strong> integer array <code>values</code> of length <code>n</code>, where <code>values[i]</code> is the <strong>value</strong> associated with the <code>i<sup>th</sup></code> node, and an integer <code>k</code>.</p>
|
||||
|
||||
<p>A <strong>valid split</strong> of the tree is obtained by removing any set of edges, possibly empty, from the tree such that the resulting components all have values that are divisible by <code>k</code>, where the <strong>value of a connected component</strong> is the sum of the values of its nodes.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum number of components</strong> in any valid split</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/08/07/example12-cropped2svg.jpg" style="width: 1024px; height: 453px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, edges = [[0,2],[1,2],[1,3],[2,4]], values = [1,8,1,4,4], k = 6
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We remove the edge connecting node 1 with 2. The resulting split is valid because:
|
||||
- The value of the component containing nodes 1 and 3 is values[1] + values[3] = 12.
|
||||
- The value of the component containing nodes 0, 2, and 4 is values[0] + values[2] + values[4] = 6.
|
||||
It can be shown that no other valid split has more than 2 connected components.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/08/07/example21svg-1.jpg" style="width: 999px; height: 338px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 7, edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]], values = [3,0,6,1,5,2,1], k = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We remove the edge connecting node 0 with 2, and the edge connecting node 0 with 1. The resulting split is valid because:
|
||||
- The value of the component containing node 0 is values[0] = 3.
|
||||
- The value of the component containing nodes 2, 5, and 6 is values[2] + values[5] + values[6] = 9.
|
||||
- The value of the component containing nodes 1, 3, and 4 is values[1] + values[3] + values[4] = 6.
|
||||
It can be shown that no other valid split has more than 3 connected components.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>edges.length == n - 1</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code></li>
|
||||
<li><code>values.length == n</code></li>
|
||||
<li><code>0 <= values[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>9</sup></code></li>
|
||||
<li>Sum of <code>values</code> is divisible by <code>k</code>.</li>
|
||||
<li>The input is generated such that <code>edges</code> represents a valid tree.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given an array <code>nums</code> consisting of <strong>non-negative</strong> integers.</p>
|
||||
|
||||
<p>We define the score of subarray <code>nums[l..r]</code> such that <code>l <= r</code> as <code>nums[l] AND nums[l + 1] AND ... AND nums[r]</code> where <strong>AND</strong> is the bitwise <code>AND</code> operation.</p>
|
||||
|
||||
<p>Consider splitting the array into one or more subarrays such that the following conditions are satisfied:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>E</strong><strong>ach</strong> element of the array belongs to <strong>exactly</strong> one subarray.</li>
|
||||
<li>The sum of scores of the subarrays is the <strong>minimum</strong> possible.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> number of subarrays in a split that satisfies the conditions above.</em></p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous part of an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,0,2,0,1,2]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can split the array into the following subarrays:
|
||||
- [1,0]. The score of this subarray is 1 AND 0 = 0.
|
||||
- [2,0]. The score of this subarray is 2 AND 0 = 0.
|
||||
- [1,2]. The score of this subarray is 1 AND 2 = 0.
|
||||
The sum of scores is 0 + 0 + 0 = 0, which is the minimum possible score that we can obtain.
|
||||
It can be shown that we cannot split the array into more than 3 subarrays with a total score of 0. So we return 3.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,7,1,3]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> We can split the array into one subarray: [5,7,1,3] with a score of 1, which is the minimum possible score that we can obtain.
|
||||
It can be shown that we cannot split the array into more than 1 subarray with a total score of 1. So we return 1.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given an array <code>nums</code> of positive integers and an integer <code>k</code>.</p>
|
||||
|
||||
<p>In one operation, you can remove the last element of the array and add it to your collection.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum number of operations</strong> needed to collect elements</em> <code>1, 2, ..., k</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,1,5,4,2], k = 2
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> After 4 operations, we collect elements 2, 4, 5, and 1, in this order. Our collection contains elements 1 and 2. Hence, the answer is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,1,5,4,2], k = 5
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> After 5 operations, we collect elements 2, 4, 5, 1, and 3, in this order. Our collection contains elements 1 through 5. Hence, the answer is 5.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,2,5,3,1], k = 3
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> After 4 operations, we collect elements 1, 3, 5, and 2, in this order. Our collection contains elements 1 through 3. Hence, the answer is 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 50</code></li>
|
||||
<li><code>1 <= nums[i] <= nums.length</code></li>
|
||||
<li><code>1 <= k <= nums.length</code></li>
|
||||
<li>The input is generated such that you can collect elements <code>1, 2, ..., k</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> and an integer <code>target</code>.</p>
|
||||
|
||||
<p>A <strong>0-indexed</strong> array <code>infinite_nums</code> is generated by infinitely appending the elements of <code>nums</code> to itself.</p>
|
||||
|
||||
<p>Return <em>the length of the <strong>shortest</strong> subarray of the array </em><code>infinite_nums</code><em> with a sum equal to </em><code>target</code><em>.</em> If there is no such subarray return <code>-1</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3], target = 5
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> In this example infinite_nums = [1,2,3,1,2,3,1,2,...].
|
||||
The subarray in the range [1,2], has the sum equal to target = 5 and length = 2.
|
||||
It can be proven that 2 is the shortest length of a subarray with sum equal to target = 5.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,1,2,3], target = 4
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> In this example infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...].
|
||||
The subarray in the range [4,5], has the sum equal to target = 4 and length = 2.
|
||||
It can be proven that 2 is the shortest length of a subarray with sum equal to target = 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,4,6,8], target = 3
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> In this example infinite_nums = [2,4,6,8,2,4,6,8,...].
|
||||
It can be proven that there is no subarray with sum equal to target = 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= target <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>There is a <strong>directed</strong> graph consisting of <code>n</code> nodes numbered from <code>0</code> to <code>n - 1</code> and <code>n</code> directed edges.</p>
|
||||
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>edges</code> where <code>edges[i]</code> indicates that there is an edge from node <code>i</code> to node <code>edges[i]</code>.</p>
|
||||
|
||||
<p>Consider the following process on the graph:</p>
|
||||
|
||||
<ul>
|
||||
<li>You start from a node <code>x</code> and keep visiting other nodes through edges until you reach a node that you have already visited before on this <strong>same</strong> process.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array </em><code>answer</code><em> where </em><code>answer[i]</code><em> is the number of <strong>different</strong> nodes that you will visit if you perform the process starting from node </em><code>i</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/08/31/graaphdrawio-1.png" />
|
||||
<pre>
|
||||
<strong>Input:</strong> edges = [1,2,0,0]
|
||||
<strong>Output:</strong> [3,3,3,4]
|
||||
<strong>Explanation:</strong> We perform the process starting from each node in the following way:
|
||||
- Starting from node 0, we visit the nodes 0 -> 1 -> 2 -> 0. The number of different nodes we visit is 3.
|
||||
- Starting from node 1, we visit the nodes 1 -> 2 -> 0 -> 1. The number of different nodes we visit is 3.
|
||||
- Starting from node 2, we visit the nodes 2 -> 0 -> 1 -> 2. The number of different nodes we visit is 3.
|
||||
- Starting from node 3, we visit the nodes 3 -> 0 -> 1 -> 2 -> 0. The number of different nodes we visit is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/08/31/graaph2drawio.png" style="width: 191px; height: 251px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> edges = [1,2,3,4,0]
|
||||
<strong>Output:</strong> [5,5,5,5,5]
|
||||
<strong>Explanation:</strong> Starting from any node we can visit every node in the graph in the process.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == edges.length</code></li>
|
||||
<li><code>2 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= edges[i] <= n - 1</code></li>
|
||||
<li><code>edges[i] != i</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
|
||||
|
||||
<p>Return <em><strong>the maximum value over all triplets of indices</strong></em> <code>(i, j, k)</code> <em>such that</em> <code>i < j < k</code>. If all such triplets have a negative value, return <code>0</code>.</p>
|
||||
|
||||
<p>The <strong>value of a triplet of indices</strong> <code>(i, j, k)</code> is equal to <code>(nums[i] - nums[j]) * nums[k]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [12,6,1,2,7]
|
||||
<strong>Output:</strong> 77
|
||||
<strong>Explanation:</strong> The value of the triplet (0, 2, 4) is (nums[0] - nums[2]) * nums[4] = 77.
|
||||
It can be shown that there are no ordered triplets of indices with a value greater than 77.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,10,3,4,19]
|
||||
<strong>Output:</strong> 133
|
||||
<strong>Explanation:</strong> The value of the triplet (1, 2, 4) is (nums[1] - nums[2]) * nums[4] = 133.
|
||||
It can be shown that there are no ordered triplets of indices with a value greater than 133.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> The only ordered triplet of indices (0, 1, 2) has a negative value of (nums[0] - nums[1]) * nums[2] = -3. Hence, the answer would be 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.</p>
|
||||
|
||||
<p>Return <em><strong>the maximum value over all triplets of indices</strong></em> <code>(i, j, k)</code> <em>such that</em> <code>i < j < k</code><em>. </em>If all such triplets have a negative value, return <code>0</code>.</p>
|
||||
|
||||
<p>The <strong>value of a triplet of indices</strong> <code>(i, j, k)</code> is equal to <code>(nums[i] - nums[j]) * nums[k]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [12,6,1,2,7]
|
||||
<strong>Output:</strong> 77
|
||||
<strong>Explanation:</strong> The value of the triplet (0, 2, 4) is (nums[0] - nums[2]) * nums[4] = 77.
|
||||
It can be shown that there are no ordered triplets of indices with a value greater than 77.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,10,3,4,19]
|
||||
<strong>Output:</strong> 133
|
||||
<strong>Explanation:</strong> The value of the triplet (1, 2, 4) is (nums[1] - nums[2]) * nums[4] = 133.
|
||||
It can be shown that there are no ordered triplets of indices with a value greater than 133.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3]
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> The only ordered triplet of indices (0, 1, 2) has a negative value of (nums[0] - nums[1]) * nums[2] = -3. Hence, the answer would be 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user