mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-04 15:01:40 +08:00
update
This commit is contained in:
File diff suppressed because it is too large
Load Diff
162
leetcode/originData/collect-coins-in-a-tree.json
Normal file
162
leetcode/originData/collect-coins-in-a-tree.json
Normal file
File diff suppressed because one or more lines are too long
162
leetcode/originData/k-items-with-the-maximum-sum.json
Normal file
162
leetcode/originData/k-items-with-the-maximum-sum.json
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
161
leetcode/originData/prime-subtraction-operation.json
Normal file
161
leetcode/originData/prime-subtraction-operation.json
Normal file
File diff suppressed because one or more lines are too long
43
leetcode/problem/collect-coins-in-a-tree.html
Normal file
43
leetcode/problem/collect-coins-in-a-tree.html
Normal file
@@ -0,0 +1,43 @@
|
||||
<p>There exists an undirected and unrooted tree with <code>n</code> nodes indexed from <code>0</code> to <code>n - 1</code>. You are given an integer <code>n</code> and a 2D integer array edges 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. You are also given an array <code>coins</code> of size <code>n</code> where <code>coins[i]</code> can be either <code>0</code> or <code>1</code>, where <code>1</code> indicates the presence of a coin in the vertex <code>i</code>.</p>
|
||||
|
||||
<p>Initially, you choose to start at any vertex in the tree. Then, you can perform the following operations any number of times: </p>
|
||||
|
||||
<ul>
|
||||
<li>Collect all the coins that are at a distance of at most <code>2</code> from the current vertex, or</li>
|
||||
<li>Move to any adjacent vertex in the tree.</li>
|
||||
</ul>
|
||||
|
||||
<p>Find <em>the minimum number of edges you need to go through to collect all the coins and go back to the initial vertex</em>.</p>
|
||||
|
||||
<p>Note that if you pass an edge several times, you need to count it into the answer several times.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/01/graph-2.png" style="width: 522px; height: 522px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> coins = [1,0,0,0,0,1], edges = [[0,1],[1,2],[2,3],[3,4],[4,5]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Start at vertex 2, collect the coin at vertex 0, move to vertex 3, collect the coin at vertex 5 then move back to vertex 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/03/02/graph-4.png" style="width: 522px; height: 522px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> coins = [0,0,0,1,1,0,0,1], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[5,6],[5,7]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Start at vertex 0, collect the coins at vertices 4 and 3, move to vertex 2, collect the coin at vertex 7, then move back to vertex 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == coins.length</code></li>
|
||||
<li><code>1 <= n <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>0 <= coins[i] <= 1</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>a<sub>i</sub> != b<sub>i</sub></code></li>
|
||||
<li><code>edges</code> represents a valid tree.</li>
|
||||
</ul>
|
||||
40
leetcode/problem/k-items-with-the-maximum-sum.html
Normal file
40
leetcode/problem/k-items-with-the-maximum-sum.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<p>There is a bag that consists of items, each item has a number <code>1</code>, <code>0</code>, or <code>-1</code> written on it.</p>
|
||||
|
||||
<p>You are given four <strong>non-negative </strong>integers <code>numOnes</code>, <code>numZeros</code>, <code>numNegOnes</code>, and <code>k</code>.</p>
|
||||
|
||||
<p>The bag initially contains:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>numOnes</code> items with <code>1</code>s written on them.</li>
|
||||
<li><code>numZeroes</code> items with <code>0</code>s written on them.</li>
|
||||
<li><code>numNegOnes</code> items with <code>-1</code>s written on them.</li>
|
||||
</ul>
|
||||
|
||||
<p>We want to pick exactly <code>k</code> items among the available items. Return <em>the <strong>maximum</strong> possible sum of numbers written on the items</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We have a bag of items with numbers written on them {1, 1, 1, 0, 0}. We take 2 items with 1 written on them and get a sum in a total of 2.
|
||||
It can be proven that 2 is the maximum possible sum.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We have a bag of items with numbers written on them {1, 1, 1, 0, 0}. We take 3 items with 1 written on them, and 1 item with 0 written on it, and get a sum in a total of 3.
|
||||
It can be proven that 3 is the maximum possible sum.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= numOnes, numZeros, numNegOnes <= 50</code></li>
|
||||
<li><code>0 <= k <= numOnes + numZeros + numNegOnes</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>You are given an array <code>nums</code> consisting of positive integers.</p>
|
||||
|
||||
<p>You are also given an integer array <code>queries</code> of size <code>m</code>. For the <code>i<sup>th</sup></code> query, you want to make all of the elements of <code>nums</code> equal to<code> queries[i]</code>. You can perform the following operation on the array <strong>any</strong> number of times:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Increase</strong> or <strong>decrease</strong> an element of the array by <code>1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array </em><code>answer</code><em> of size </em><code>m</code><em> where </em><code>answer[i]</code><em> is the <strong>minimum</strong> number of operations to make all elements of </em><code>nums</code><em> equal to </em><code>queries[i]</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that after each query the array is reset to its original state.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,1,6,8], queries = [1,5]
|
||||
<strong>Output:</strong> [14,10]
|
||||
<strong>Explanation:</strong> For the first query we can do the following operations:
|
||||
- Decrease nums[0] 2 times, so that nums = [1,1,6,8].
|
||||
- Decrease nums[2] 5 times, so that nums = [1,1,1,8].
|
||||
- Decrease nums[3] 7 times, so that nums = [1,1,1,1].
|
||||
So the total number of operations for the first query is 2 + 5 + 7 = 14.
|
||||
For the second query we can do the following operations:
|
||||
- Increase nums[0] 2 times, so that nums = [5,1,6,8].
|
||||
- Increase nums[1] 4 times, so that nums = [5,5,6,8].
|
||||
- Decrease nums[2] 1 time, so that nums = [5,5,5,8].
|
||||
- Decrease nums[3] 3 times, so that nums = [5,5,5,5].
|
||||
So the total number of operations for the second query is 2 + 4 + 1 + 3 = 10.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,9,6,3], queries = [10]
|
||||
<strong>Output:</strong> [20]
|
||||
<strong>Explanation:</strong> We can increase each value in the array to 10. The total number of operations will be 8 + 1 + 4 + 7 = 20.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>m == queries.length</code></li>
|
||||
<li><code>1 <= n, m <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i], queries[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
44
leetcode/problem/prime-subtraction-operation.html
Normal file
44
leetcode/problem/prime-subtraction-operation.html
Normal file
@@ -0,0 +1,44 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> of length <code>n</code>.</p>
|
||||
|
||||
<p>You can perform the following operation as many times as you want:</p>
|
||||
|
||||
<ul>
|
||||
<li>Pick an index <code>i</code> that you haven’t picked before, and pick a prime <code>p</code> <strong>strictly less than</strong> <code>nums[i]</code>, then subtract <code>p</code> from <code>nums[i]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>true if you can make <code>nums</code> a strictly increasing array using the above operation and false otherwise.</em></p>
|
||||
|
||||
<p>A <strong>strictly increasing array</strong> is an array whose each element is strictly greater than its preceding element.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4,9,6,10]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> In the first operation: Pick i = 0 and p = 3, and then subtract 3 from nums[0], so that nums becomes [1,9,6,10].
|
||||
In the second operation: i = 1, p = 7, subtract 7 from nums[1], so nums becomes equal to [1,2,6,10].
|
||||
After the second operation, nums is sorted in strictly increasing order, so the answer is true.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [6,8,11,12]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation: </strong>Initially nums is sorted in strictly increasing order, so we don't need to make any operations.</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,8,3]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> It can be proven that there is no way to perform operations to make nums sorted in strictly increasing order, so the answer is false.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i] <= 1000</code></li>
|
||||
<li><code><font face="monospace">nums.length == n</font></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user