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>There are some prizes on the <strong>X-axis</strong>. You are given an integer array <code>prizePositions</code> that is <strong>sorted in non-decreasing order</strong>, where <code>prizePositions[i]</code> is the position of the <code>i<sup>th</sup></code> prize. There could be different prizes at the same position on the line. You are also given an integer <code>k</code>.</p>
|
||||
|
||||
<p>You are allowed to select two segments with integer endpoints. The length of each segment must be <code>k</code>. You will collect all prizes whose position falls within at least one of the two selected segments (including the endpoints of the segments). The two selected segments may intersect.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example if <code>k = 2</code>, you can choose segments <code>[1, 3]</code> and <code>[2, 4]</code>, and you will win any prize <font face="monospace">i</font> that satisfies <code>1 <= prizePositions[i] <= 3</code> or <code>2 <= prizePositions[i] <= 4</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> number of prizes you can win if you choose the two segments optimally</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prizePositions = [1,1,2,2,3,3,5], k = 2
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> In this example, you can win all 7 prizes by selecting two segments [1, 3] and [3, 5].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prizePositions = [1,2,3,4], k = 0
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> For this example, <strong>one choice</strong> for the segments is <code>[3, 3]</code> and <code>[4, 4],</code> and you will be able to get <code>2</code> prizes.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= prizePositions.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= prizePositions[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= k <= 10<sup>9</sup> </code></li>
|
||||
<li><code>prizePositions</code> is sorted in non-decreasing order.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0;
|
||||
}
|
||||
.spoiler {overflow:hidden;}
|
||||
.spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
|
||||
.spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
|
||||
.spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
|
||||
</style>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> <strong>binary</strong> matrix <code>grid</code>. You can move from a cell <code>(row, col)</code> to any of the cells <code>(row + 1, col)</code> or <code>(row, col + 1)</code> that has the value <code>1</code>. The matrix is <strong>disconnected</strong> if there is no path from <code>(0, 0)</code> to <code>(m - 1, n - 1)</code>.</p>
|
||||
|
||||
<p>You can flip the value of <strong>at most one</strong> (possibly none) cell. You <strong>cannot flip</strong> the cells <code>(0, 0)</code> and <code>(m - 1, n - 1)</code>.</p>
|
||||
|
||||
<p>Return <code>true</code> <em>if it is possible to make the matrix disconnect or </em><code>false</code><em> otherwise</em>.</p>
|
||||
|
||||
<p><strong>Note</strong> that flipping a cell changes its value from <code>0</code> to <code>1</code> or from <code>1</code> to <code>0</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/12/07/yetgrid2drawio.png" style="width: 441px; height: 151px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,1,1],[1,0,0],[1,1,1]]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> We can change the cell shown in the diagram above. There is no path from (0, 0) to (2, 2) in the resulting grid.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2022/12/07/yetgrid3drawio.png" />
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,1,1],[1,0,1],[1,1,1]]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> It is not possible to change at most one cell such that there is not path from (0, 0) to (2, 2).
|
||||
</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 <= 1000</code></li>
|
||||
<li><code>1 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
|
||||
<li><code>grid[0][0] == grid[m - 1][n - 1] == 1</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You are given an integer array <code>banned</code> and two integers <code>n</code> and <code>maxSum</code>. You are choosing some number of integers following the below rules:</p>
|
||||
|
||||
<ul>
|
||||
<li>The chosen integers have to be in the range <code>[1, n]</code>.</li>
|
||||
<li>Each integer can be chosen <strong>at most once</strong>.</li>
|
||||
<li>The chosen integers should not be in the array <code>banned</code>.</li>
|
||||
<li>The sum of the chosen integers should not exceed <code>maxSum</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> number of integers you can choose following the mentioned rules</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> banned = [1,6,5], n = 5, maxSum = 6
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> You can choose the integers 2 and 4.
|
||||
2 and 4 are from the range [1, 5], both did not appear in banned, and their sum is 6, which did not exceed maxSum.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> banned = [1,2,3,4,5,6,7], n = 8, maxSum = 1
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> You cannot choose any integer while following the mentioned conditions.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> banned = [11], n = 7, maxSum = 50
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> You can choose the integers 1, 2, 3, 4, 5, 6, and 7.
|
||||
They are from the range [1, 7], all did not appear in banned, and their sum is 28, which did not exceed maxSum.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= banned.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= banned[i], n <= 10<sup>4</sup></code></li>
|
||||
<li><code>1 <= maxSum <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>You are given an integer array <code>gifts</code> denoting the number of gifts in various piles. Every second, you do the following:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose the pile with the maximum number of gifts.</li>
|
||||
<li>If there is more than one pile with the maximum number of gifts, choose any.</li>
|
||||
<li>Leave behind the floor of the square root of the number of gifts in the pile. Take the rest of the gifts.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the number of gifts remaining after </em><code>k</code><em> seconds.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> gifts = [25,64,9,4,100], k = 4
|
||||
<strong>Output:</strong> 29
|
||||
<strong>Explanation:</strong>
|
||||
The gifts are taken in the following way:
|
||||
- In the first second, the last pile is chosen and 10 gifts are left behind.
|
||||
- Then the second pile is chosen and 8 gifts are left behind.
|
||||
- After that the first pile is chosen and 5 gifts are left behind.
|
||||
- Finally, the last pile is chosen again and 3 gifts are left behind.
|
||||
The final remaining gifts are [5,8,9,4,3], so the total number of gifts remaining is 29.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> gifts = [1,1,1,1], k = 4
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong>
|
||||
In this case, regardless which pile you choose, you have to leave behind 1 gift in each pile.
|
||||
That is, you can't take any pile with you.
|
||||
So, the total gifts remaining are 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= gifts.length <= 10<sup>3</sup></code></li>
|
||||
<li><code>1 <= gifts[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>3</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,38 @@
|
||||
<p>Given an array of positive integers <code>nums</code>, return <em>an array </em><code>answer</code><em> that consists of the digits of each integer in </em><code>nums</code><em> after separating them in <strong>the same order</strong> they appear in </em><code>nums</code>.</p>
|
||||
|
||||
<p>To separate the digits of an integer is to get all the digits it has in the same order.</p>
|
||||
|
||||
<ul>
|
||||
<li>For example, for the integer <code>10921</code>, the separation of its digits is <code>[1,0,9,2,1]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [13,25,83,77]
|
||||
<strong>Output:</strong> [1,3,2,5,8,3,7,7]
|
||||
<strong>Explanation:</strong>
|
||||
- The separation of 13 is [1,3].
|
||||
- The separation of 25 is [2,5].
|
||||
- The separation of 83 is [8,3].
|
||||
- The separation of 77 is [7,7].
|
||||
answer = [1,3,2,5,8,3,7,7]. Note that answer contains the separations in the same order.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [7,1,3,9]
|
||||
<strong>Output:</strong> [7,1,3,9]
|
||||
<strong>Explanation:</strong> The separation of each integer in nums is itself.
|
||||
answer = [7,1,3,9].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>There are several consecutive houses along a street, each of which has some money inside. There is also a robber, who wants to steal money from the homes, but he <strong>refuses to steal from adjacent homes</strong>.</p>
|
||||
|
||||
<p>The <strong>capability</strong> of the robber is the maximum amount of money he steals from one house of all the houses he robbed.</p>
|
||||
|
||||
<p>You are given an integer array <code>nums</code> representing how much money is stashed in each house. More formally, the <code>i<sup>th</sup></code> house from the left has <code>nums[i]</code> dollars.</p>
|
||||
|
||||
<p>You are also given an integer <code>k</code>, representing the <strong>minimum</strong> number of houses the robber will steal from. It is always possible to steal at least <code>k</code> houses.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> capability of the robber out of all the possible ways to steal at least </em><code>k</code><em> houses</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,3,5,9], k = 2
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong>
|
||||
There are three ways to rob at least 2 houses:
|
||||
- Rob the houses at indices 0 and 2. Capability is max(nums[0], nums[2]) = 5.
|
||||
- Rob the houses at indices 0 and 3. Capability is max(nums[0], nums[3]) = 9.
|
||||
- Rob the houses at indices 1 and 3. Capability is max(nums[1], nums[3]) = 9.
|
||||
Therefore, we return min(5, 9, 9) = 5.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,7,9,3,1], k = 2
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> There are 7 ways to rob the houses. The way which leads to minimum capability is to rob the house at index 0 and 4. Return max(nums[0], nums[4]) = 2.
|
||||
</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>9</sup></code></li>
|
||||
<li><code>1 <= k <= (nums.length + 1)/2</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array of strings <code>words</code> and a 2D array of integers <code>queries</code>.</p>
|
||||
|
||||
<p>Each query <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>]</code> asks us to find the number of strings present in the range <code>l<sub>i</sub></code> to <code>r<sub>i</sub></code> (both <strong>inclusive</strong>) of <code>words</code> that start and end with a vowel.</p>
|
||||
|
||||
<p>Return <em>an array </em><code>ans</code><em> of size </em><code>queries.length</code><em>, where </em><code>ans[i]</code><em> is the answer to the </em><code>i</code><sup>th</sup><em> query</em>.</p>
|
||||
|
||||
<p><strong>Note</strong> that the vowel letters are <code>'a'</code>, <code>'e'</code>, <code>'i'</code>, <code>'o'</code>, and <code>'u'</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["aba","bcb","ece","aa","e"], queries = [[0,2],[1,4],[1,1]]
|
||||
<strong>Output:</strong> [2,3,0]
|
||||
<strong>Explanation:</strong> The strings starting and ending with a vowel are "aba", "ece", "aa" and "e".
|
||||
The answer to the query [0,2] is 2 (strings "aba" and "ece").
|
||||
to query [1,4] is 3 (strings "ece", "aa", "e").
|
||||
to query [1,1] is 0.
|
||||
We return [2,3,0].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> words = ["a","e","i"], queries = [[0,2],[0,1],[2,2]]
|
||||
<strong>Output:</strong> [3,2,1]
|
||||
<strong>Explanation:</strong> Every string satisfies the conditions, so we return [3,2,1].</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= words.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= words[i].length <= 40</code></li>
|
||||
<li><code>words[i]</code> consists only of lowercase English letters.</li>
|
||||
<li><code>sum(words[i].length) <= 3 * 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= l<sub>i</sub> <= r<sub>i</sub> < words.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You have two fruit baskets containing <code>n</code> fruits each. You are given two <strong>0-indexed</strong> integer arrays <code>basket1</code> and <code>basket2</code> representing the cost of fruit in each basket. You want to make both baskets <strong>equal</strong>. To do so, you can use the following operation as many times as you want:</p>
|
||||
|
||||
<ul>
|
||||
<li>Chose two indices <code>i</code> and <code>j</code>, and swap the <code>i<sup>th</sup> </code>fruit of <code>basket1</code> with the <code>j<sup>th</sup></code> fruit of <code>basket2</code>.</li>
|
||||
<li>The cost of the swap is <code>min(basket1[i],basket2[j])</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Two baskets are considered equal if sorting them according to the fruit cost makes them exactly the same baskets.</p>
|
||||
|
||||
<p>Return <em>the minimum cost to make both the baskets equal or </em><code>-1</code><em> if impossible.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> basket1 = [4,2,2,2], basket2 = [1,4,1,2]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Swap index 1 of basket1 with index 0 of basket2, which has cost 1. Now basket1 = [4,1,2,2] and basket2 = [2,4,1,2]. Rearranging both the arrays makes them equal.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> basket1 = [2,3,4,1], basket2 = [3,2,5,1]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> It can be shown that it is impossible to make both the baskets equal.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>basket1.length == bakste2.length</code></li>
|
||||
<li><code>1 <= basket1.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= basket1[i],basket2[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user