mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-06 07:51:41 +08:00
update
This commit is contained in:
@@ -0,0 +1,52 @@
|
||||
<p>You are given an array of digits called <code>digits</code>. Your task is to determine the number of <strong>distinct</strong> three-digit even numbers that can be formed using these digits.</p>
|
||||
|
||||
<p><strong>Note</strong>: Each <em>copy</em> of a digit can only be used <strong>once per number</strong>, and there may <strong>not</strong> be leading zeros.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">digits = [1,2,3,4]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">12</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong> The 12 distinct 3-digit even numbers that can be formed are 124, 132, 134, 142, 214, 234, 312, 314, 324, 342, 412, and 432. Note that 222 cannot be formed because there is only 1 copy of the digit 2.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">digits = [0,2,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong> The only 3-digit even numbers that can be formed are 202 and 220. Note that the digit 2 can be used twice because it appears twice in the array.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">digits = [6,6,6]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">1</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong> Only 666 can be formed.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 4:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">digits = [1,3,5]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">0</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong> No even 3-digit numbers can be formed.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= digits.length <= 10</code></li>
|
||||
<li><code>0 <= digits[i] <= 9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>You are given an integer array <code>nums</code> and two integers, <code>x</code> and <code>k</code>. You can perform the following operation any number of times (<strong>including zero</strong>):</p>
|
||||
|
||||
<ul>
|
||||
<li>Increase or decrease any element of <code>nums</code> by 1.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return the <strong>minimum</strong> number of operations needed to have <strong>at least</strong> <code>k</code> <em>non-overlapping <span data-keyword="subarray-nonempty">subarrays</span></em> of size <strong>exactly</strong> <code>x</code> in <code>nums</code>, where all elements within each subarray are equal.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [5,-2,1,3,7,3,6,4,-1], x = 3, k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">8</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Use 3 operations to add 3 to <code>nums[1]</code> and use 2 operations to subtract 2 from <code>nums[3]</code>. The resulting array is <code>[5, 1, 1, 1, 7, 3, 6, 4, -1]</code>.</li>
|
||||
<li>Use 1 operation to add 1 to <code>nums[5]</code> and use 2 operations to subtract 2 from <code>nums[6]</code>. The resulting array is <code>[5, 1, 1, 1, 7, 4, 4, 4, -1]</code>.</li>
|
||||
<li>Now, all elements within each subarray <code>[1, 1, 1]</code> (from indices 1 to 3) and <code>[4, 4, 4]</code> (from indices 5 to 7) are equal. Since 8 total operations were used, 8 is the output.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [9,-2,-2,-2,1,5], x = 2, k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">3</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Use 3 operations to subtract 3 from <code>nums[4]</code>. The resulting array is <code>[9, -2, -2, -2, -2, 5]</code>.</li>
|
||||
<li>Now, all elements within each subarray <code>[-2, -2]</code> (from indices 1 to 2) and <code>[-2, -2]</code> (from indices 3 to 4) are equal. Since 3 operations were used, 3 is the output.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>6</sup> <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>2 <= x <= nums.length</code></li>
|
||||
<li><code>1 <= k <= 15</code></li>
|
||||
<li><code>2 <= k * x <= nums.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,73 @@
|
||||
<p>You are given a 2D array <code>queries</code>, where <code>queries[i]</code> is of the form <code>[l, r]</code>. Each <code>queries[i]</code> defines an array of integers <code>nums</code> consisting of elements ranging from <code>l</code> to <code>r</code>, both <strong>inclusive</strong>.</p>
|
||||
|
||||
<p>In one operation, you can:</p>
|
||||
|
||||
<ul>
|
||||
<li>Select two integers <code>a</code> and <code>b</code> from the array.</li>
|
||||
<li>Replace them with <code>floor(a / 4)</code> and <code>floor(b / 4)</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Your task is to determine the <strong>minimum</strong> number of operations required to reduce all elements of the array to zero for each query. Return the sum of the results for all queries.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">queries = [[1,2],[2,4]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">3</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>For <code>queries[0]</code>:</p>
|
||||
|
||||
<ul>
|
||||
<li>The initial array is <code>nums = [1, 2]</code>.</li>
|
||||
<li>In the first operation, select <code>nums[0]</code> and <code>nums[1]</code>. The array becomes <code>[0, 0]</code>.</li>
|
||||
<li>The minimum number of operations required is 1.</li>
|
||||
</ul>
|
||||
|
||||
<p>For <code>queries[1]</code>:</p>
|
||||
|
||||
<ul>
|
||||
<li>The initial array is <code>nums = [2, 3, 4]</code>.</li>
|
||||
<li>In the first operation, select <code>nums[0]</code> and <code>nums[2]</code>. The array becomes <code>[0, 3, 1]</code>.</li>
|
||||
<li>In the second operation, select <code>nums[1]</code> and <code>nums[2]</code>. The array becomes <code>[0, 0, 0]</code>.</li>
|
||||
<li>The minimum number of operations required is 2.</li>
|
||||
</ul>
|
||||
|
||||
<p>The output is <code>1 + 2 = 3</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">queries = [[2,6]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>For <code>queries[0]</code>:</p>
|
||||
|
||||
<ul>
|
||||
<li>The initial array is <code>nums = [2, 3, 4, 5, 6]</code>.</li>
|
||||
<li>In the first operation, select <code>nums[0]</code> and <code>nums[3]</code>. The array becomes <code>[0, 3, 4, 1, 6]</code>.</li>
|
||||
<li>In the second operation, select <code>nums[2]</code> and <code>nums[4]</code>. The array becomes <code>[0, 3, 1, 1, 1]</code>.</li>
|
||||
<li>In the third operation, select <code>nums[1]</code> and <code>nums[2]</code>. The array becomes <code>[0, 0, 0, 1, 1]</code>.</li>
|
||||
<li>In the fourth operation, select <code>nums[3]</code> and <code>nums[4]</code>. The array becomes <code>[0, 0, 0, 0, 0]</code>.</li>
|
||||
<li>The minimum number of operations required is 4.</li>
|
||||
</ul>
|
||||
|
||||
<p>The output is 4.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>queries[i].length == 2</code></li>
|
||||
<li><code>queries[i] == [l, r]</code></li>
|
||||
<li><code>1 <= l < r <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,116 @@
|
||||
<p>Table: <code>UserActivity</code></p>
|
||||
|
||||
<pre>
|
||||
+------------------+---------+
|
||||
| Column Name | Type |
|
||||
+------------------+---------+
|
||||
| user_id | int |
|
||||
| activity_date | date |
|
||||
| activity_type | varchar |
|
||||
| activity_duration| int |
|
||||
+------------------+---------+
|
||||
(user_id, activity_date, activity_type) is the unique key for this table.
|
||||
activity_type is one of ('free_trial', 'paid', 'cancelled').
|
||||
activity_duration is the number of minutes the user spent on the platform that day.
|
||||
Each row represents a user's activity on a specific date.
|
||||
</pre>
|
||||
|
||||
<p>A subscription service wants to analyze user behavior patterns. The company offers a <code>7</code>-day <strong>free trial</strong>, after which users can subscribe to a <strong>paid plan</strong> or <strong>cancel</strong>. Write a solution to:</p>
|
||||
|
||||
<ol>
|
||||
<li>Find users who converted from free trial to paid subscription</li>
|
||||
<li>Calculate each user's <strong>average daily activity duration</strong> during their <strong>free trial</strong> period (rounded to <code>2</code> decimal places)</li>
|
||||
<li>Calculate each user's <strong>average daily activity duration</strong> during their <strong>paid</strong> subscription period (rounded to <code>2</code> decimal places)</li>
|
||||
</ol>
|
||||
|
||||
<p>Return <em>the result table ordered by </em><code>user_id</code><em> in <strong>ascending</strong> order</em>.</p>
|
||||
|
||||
<p>The result format is in the following example.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong></p>
|
||||
|
||||
<p>UserActivity table:</p>
|
||||
|
||||
<pre class="example-io">
|
||||
+---------+---------------+---------------+-------------------+
|
||||
| user_id | activity_date | activity_type | activity_duration |
|
||||
+---------+---------------+---------------+-------------------+
|
||||
| 1 | 2023-01-01 | free_trial | 45 |
|
||||
| 1 | 2023-01-02 | free_trial | 30 |
|
||||
| 1 | 2023-01-05 | free_trial | 60 |
|
||||
| 1 | 2023-01-10 | paid | 75 |
|
||||
| 1 | 2023-01-12 | paid | 90 |
|
||||
| 1 | 2023-01-15 | paid | 65 |
|
||||
| 2 | 2023-02-01 | free_trial | 55 |
|
||||
| 2 | 2023-02-03 | free_trial | 25 |
|
||||
| 2 | 2023-02-07 | free_trial | 50 |
|
||||
| 2 | 2023-02-10 | cancelled | 0 |
|
||||
| 3 | 2023-03-05 | free_trial | 70 |
|
||||
| 3 | 2023-03-06 | free_trial | 60 |
|
||||
| 3 | 2023-03-08 | free_trial | 80 |
|
||||
| 3 | 2023-03-12 | paid | 50 |
|
||||
| 3 | 2023-03-15 | paid | 55 |
|
||||
| 3 | 2023-03-20 | paid | 85 |
|
||||
| 4 | 2023-04-01 | free_trial | 40 |
|
||||
| 4 | 2023-04-03 | free_trial | 35 |
|
||||
| 4 | 2023-04-05 | paid | 45 |
|
||||
| 4 | 2023-04-07 | cancelled | 0 |
|
||||
+---------+---------------+---------------+-------------------+
|
||||
</pre>
|
||||
|
||||
<p><strong>Output:</strong></p>
|
||||
|
||||
<pre class="example-io">
|
||||
+---------+--------------------+-------------------+
|
||||
| user_id | trial_avg_duration | paid_avg_duration |
|
||||
+---------+--------------------+-------------------+
|
||||
| 1 | 45.00 | 76.67 |
|
||||
| 3 | 70.00 | 63.33 |
|
||||
| 4 | 37.50 | 45.00 |
|
||||
+---------+--------------------+-------------------+
|
||||
</pre>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><strong>User 1:</strong>
|
||||
|
||||
<ul>
|
||||
<li>Had 3 days of free trial with durations of 45, 30, and 60 minutes.</li>
|
||||
<li>Average trial duration: (45 + 30 + 60) / 3 = 45.00 minutes.</li>
|
||||
<li>Had 3 days of paid subscription with durations of 75, 90, and 65 minutes.</li>
|
||||
<li>Average paid duration: (75 + 90 + 65) / 3 = 76.67 minutes.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><strong>User 2:</strong>
|
||||
<ul>
|
||||
<li>Had 3 days of free trial with durations of 55, 25, and 50 minutes.</li>
|
||||
<li>Average trial duration: (55 + 25 + 50) / 3 = 43.33 minutes.</li>
|
||||
<li>Did not convert to a paid subscription (only had free_trial and cancelled activities).</li>
|
||||
<li>Not included in the output because they didn't convert to paid.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><strong>User 3:</strong>
|
||||
<ul>
|
||||
<li>Had 3 days of free trial with durations of 70, 60, and 80 minutes.</li>
|
||||
<li>Average trial duration: (70 + 60 + 80) / 3 = 70.00 minutes.</li>
|
||||
<li>Had 3 days of paid subscription with durations of 50, 55, and 85 minutes.</li>
|
||||
<li>Average paid duration: (50 + 55 + 85) / 3 = 63.33 minutes.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><strong>User 4:</strong>
|
||||
<ul>
|
||||
<li>Had 2 days of free trial with durations of 40 and 35 minutes.</li>
|
||||
<li>Average trial duration: (40 + 35) / 2 = 37.50 minutes.</li>
|
||||
<li>Had 1 day of paid subscription with duration of 45 minutes before cancelling.</li>
|
||||
<li>Average paid duration: 45.00 minutes.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
<p>The result table only includes users who converted from free trial to paid subscription (users 1, 3, and 4), and is ordered by user_id in ascending order.</p>
|
||||
</div>
|
||||
@@ -0,0 +1,69 @@
|
||||
<p>You are given an array of strings <code>words</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>For each index <code>i</code> in the range <code>[0, words.length - 1]</code>, find the <strong>length</strong> of the <strong>longest common <span data-keyword="string-prefix">prefix</span></strong> among any <code>k</code> strings (selected at <strong>distinct indices</strong>) from the remaining array after removing the <code>i<sup>th</sup></code> element.</p>
|
||||
|
||||
<p>Return an array <code>answer</code>, where <code>answer[i]</code> is the answer for <code>i<sup>th</sup></code> element. If removing the <code>i<sup>th</sup></code> element leaves the array with fewer than <code>k</code> strings, <code>answer[i]</code> is 0.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["jump","run","run","jump","run"], k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[3,4,4,3,4]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Removing index 0 (<code>"jump"</code>):
|
||||
|
||||
<ul>
|
||||
<li><code>words</code> becomes: <code>["run", "run", "jump", "run"]</code>. <code>"run"</code> occurs 3 times. Choosing any two gives the longest common prefix <code>"run"</code> (length 3).</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Removing index 1 (<code>"run"</code>):
|
||||
<ul>
|
||||
<li><code>words</code> becomes: <code>["jump", "run", "jump", "run"]</code>. <code>"jump"</code> occurs twice. Choosing these two gives the longest common prefix <code>"jump"</code> (length 4).</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Removing index 2 (<code>"run"</code>):
|
||||
<ul>
|
||||
<li><code>words</code> becomes: <code>["jump", "run", "jump", "run"]</code>. <code>"jump"</code> occurs twice. Choosing these two gives the longest common prefix <code>"jump"</code> (length 4).</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Removing index 3 (<code>"jump"</code>):
|
||||
<ul>
|
||||
<li><code>words</code> becomes: <code>["jump", "run", "run", "run"]</code>. <code>"run"</code> occurs 3 times. Choosing any two gives the longest common prefix <code>"run"</code> (length 3).</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Removing index 4 ("run"):
|
||||
<ul>
|
||||
<li><code>words</code> becomes: <code>["jump", "run", "run", "jump"]</code>. <code>"jump"</code> occurs twice. Choosing these two gives the longest common prefix <code>"jump"</code> (length 4).</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">words = ["dog","racer","car"], k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[0,0,0]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Removing any index results in an answer of 0.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= k <= words.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= words[i].length <= 10<sup>4</sup></code></li>
|
||||
<li><code>words[i]</code> consists of lowercase English letters.</li>
|
||||
<li>The sum of <code>words[i].length</code> is smaller than or equal <code>10<sup>5</sup></code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,55 @@
|
||||
<p>You are given an integer array <code>nums</code>.</p>
|
||||
|
||||
<p>You are allowed to delete any number of elements from <code>nums</code> without making it <strong>empty</strong>. After performing the deletions, select a <span data-keyword="subarray-nonempty">subarray</span> of <code>nums</code> such that:</p>
|
||||
|
||||
<ol>
|
||||
<li>All elements in the subarray are <strong>unique</strong>.</li>
|
||||
<li>The sum of the elements in the subarray is <strong>maximized</strong>.</li>
|
||||
</ol>
|
||||
|
||||
<p>Return the <strong>maximum sum</strong> of such a subarray.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,2,3,4,5]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">15</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Select the entire array without deleting any element to obtain the maximum sum.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,1,0,1,1]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 1</p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Delete the element <code>nums[0] == 1</code>, <code>nums[1] == 1</code>, <code>nums[2] == 0</code>, and <code>nums[3] == 1</code>. Select the entire array <code>[1]</code> to obtain the maximum sum.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,2,-1,-2,1,0,-1]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 3</p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Delete the elements <code>nums[2] == -1</code> and <code>nums[3] == -2</code>, and select the subarray <code>[2, 1]</code> from <code>[1, 2, 1, 0, -1]</code> to obtain the maximum sum.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>-100 <= nums[i] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,54 @@
|
||||
<p data-end="438" data-start="104">You are given an integer array <code data-end="119" data-start="113">cost</code> of size <code data-end="131" data-start="128">n</code>. You are currently at position <code data-end="166" data-start="163">n</code> (at the end of the line) in a line of <code data-end="187" data-start="180">n + 1</code> people (numbered from 0 to <code data-end="218" data-start="215">n</code>).</p>
|
||||
|
||||
<p data-end="438" data-start="104">You wish to move forward in the line, but each person in front of you charges a specific amount to <strong>swap</strong> places. The cost to swap with person <code data-end="375" data-start="372">i</code> is given by <code data-end="397" data-start="388">cost[i]</code>.</p>
|
||||
|
||||
<p data-end="487" data-start="440">You are allowed to swap places with people as follows:</p>
|
||||
|
||||
<ul data-end="632" data-start="488">
|
||||
<li data-end="572" data-start="488">If they are in front of you, you <strong>must</strong> pay them <code data-end="546" data-start="537">cost[i]</code> to swap with them.</li>
|
||||
<li data-end="632" data-start="573">If they are behind you, they can swap with you for free.</li>
|
||||
</ul>
|
||||
|
||||
<p data-end="755" data-start="634">Return an array <code>answer</code> of size <code>n</code>, where <code>answer[i]</code> is the <strong data-end="680" data-start="664">minimum</strong> total cost to reach each position <code>i</code> in the line<font face="monospace">.</font></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">cost = [5,3,4,1,3,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[5,3,3,1,1,1]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>We can get to each position in the following way:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>i = 0</code>. We can swap with person 0 for a cost of 5.</li>
|
||||
<li><span class="example-io"><code><font face="monospace">i = </font>1</code>. We can swap with person 1 for a cost of 3.</span></li>
|
||||
<li><span class="example-io"><code>i = 2</code>. We can swap with person 1 for a cost of 3, then swap with person 2 for free.</span></li>
|
||||
<li><span class="example-io"><code>i = 3</code>. We can swap with person 3 for a cost of 1.</span></li>
|
||||
<li><span class="example-io"><code>i = 4</code>. We can swap with person 3 for a cost of 1, then swap with person 4 for free.</span></li>
|
||||
<li><span class="example-io"><code>i = 5</code>. We can swap with person 3 for a cost of 1, then swap with person 5 for free.</span></li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">cost = [1,2,4,6,7]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[1,1,1,1,1]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>We can swap with person 0 for a cost of <span class="example-io">1, then we will be able to reach any position <code>i</code> for free.</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == cost.length <= 100</code></li>
|
||||
<li><code>1 <= cost[i] <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,62 @@
|
||||
<p>You are given two strings, <code>s</code> and <code>t</code>.</p>
|
||||
|
||||
<p>You can create a new string by selecting a <span data-keyword="substring">substring</span> from <code>s</code> (possibly empty) and a substring from <code>t</code> (possibly empty), then concatenating them <strong>in order</strong>.</p>
|
||||
|
||||
<p>Return the length of the <strong>longest</strong> <span data-keyword="palindrome-string">palindrome</span> that can be formed this way.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "a", t = "a"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Concatenating <code>"a"</code> from <code>s</code> and <code>"a"</code> from <code>t</code> results in <code>"aa"</code>, which is a palindrome of length 2.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "abc", t = "def"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">1</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Since all characters are different, the longest palindrome is any single character, so the answer is 1.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "b", t = "aaaa"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 4</p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Selecting "<code>aaaa</code>" from <code>t</code> is the longest palindrome, so the answer is 4.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 4:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "abcde", t = "ecdba"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 5</p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Concatenating <code>"abc"</code> from <code>s</code> and <code>"ba"</code> from <code>t</code> results in <code>"abcba"</code>, which is a palindrome of length 5.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length, t.length <= 30</code></li>
|
||||
<li><code>s</code> and <code>t</code> consist of lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,62 @@
|
||||
<p>You are given two strings, <code>s</code> and <code>t</code>.</p>
|
||||
|
||||
<p>You can create a new string by selecting a <span data-keyword="substring">substring</span> from <code>s</code> (possibly empty) and a substring from <code>t</code> (possibly empty), then concatenating them <strong>in order</strong>.</p>
|
||||
|
||||
<p>Return the length of the <strong>longest</strong> <span data-keyword="palindrome-string">palindrome</span> that can be formed this way.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "a", t = "a"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Concatenating <code>"a"</code> from <code>s</code> and <code>"a"</code> from <code>t</code> results in <code>"aa"</code>, which is a palindrome of length 2.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "abc", t = "def"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">1</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Since all characters are different, the longest palindrome is any single character, so the answer is 1.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "b", t = "aaaa"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Selecting "<code>aaaa</code>" from <code>t</code> is the longest palindrome, so the answer is 4.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 4:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "abcde", t = "ecdba"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">5</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Concatenating <code>"abc"</code> from <code>s</code> and <code>"ba"</code> from <code>t</code> results in <code>"abcba"</code>, which is a palindrome of length 5.</p>
|
||||
</div>
|
||||
|
||||
<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 lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,107 @@
|
||||
<p>Given a string <code>s</code>, calculate its <strong>reverse degree</strong>.</p>
|
||||
|
||||
<p>The <strong>reverse degree</strong> is calculated as follows:</p>
|
||||
|
||||
<ol>
|
||||
<li>For each character, multiply its position in the <em>reversed</em> alphabet (<code>'a'</code> = 26, <code>'b'</code> = 25, ..., <code>'z'</code> = 1) with its position in the string <strong>(1-indexed)</strong>.</li>
|
||||
<li>Sum these products for all characters in the string.</li>
|
||||
</ol>
|
||||
|
||||
<p>Return the <strong>reverse degree</strong> of <code>s</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "abc"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">148</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<table style="border: 1px solid black;">
|
||||
<tbody>
|
||||
<tr>
|
||||
<th style="border: 1px solid black;">Letter</th>
|
||||
<th style="border: 1px solid black;">Index in Reversed Alphabet</th>
|
||||
<th style="border: 1px solid black;">Index in String</th>
|
||||
<th style="border: 1px solid black;">Product</th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;"><code>'a'</code></td>
|
||||
<td style="border: 1px solid black;">26</td>
|
||||
<td style="border: 1px solid black;">1</td>
|
||||
<td style="border: 1px solid black;">26</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;"><code>'b'</code></td>
|
||||
<td style="border: 1px solid black;">25</td>
|
||||
<td style="border: 1px solid black;">2</td>
|
||||
<td style="border: 1px solid black;">50</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;"><code>'c'</code></td>
|
||||
<td style="border: 1px solid black;">24</td>
|
||||
<td style="border: 1px solid black;">3</td>
|
||||
<td style="border: 1px solid black;">72</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p>The reversed degree is <code>26 + 50 + 72 = 148</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "zaza"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">160</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<table style="border: 1px solid black;">
|
||||
<tbody>
|
||||
<tr>
|
||||
<th style="border: 1px solid black;">Letter</th>
|
||||
<th style="border: 1px solid black;">Index in Reversed Alphabet</th>
|
||||
<th style="border: 1px solid black;">Index in String</th>
|
||||
<th style="border: 1px solid black;">Product</th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;"><code>'z'</code></td>
|
||||
<td style="border: 1px solid black;">1</td>
|
||||
<td style="border: 1px solid black;">1</td>
|
||||
<td style="border: 1px solid black;">1</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;"><code>'a'</code></td>
|
||||
<td style="border: 1px solid black;">26</td>
|
||||
<td style="border: 1px solid black;">2</td>
|
||||
<td style="border: 1px solid black;">52</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;"><code>'z'</code></td>
|
||||
<td style="border: 1px solid black;">1</td>
|
||||
<td style="border: 1px solid black;">3</td>
|
||||
<td style="border: 1px solid black;">3</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;"><code>'a'</code></td>
|
||||
<td style="border: 1px solid black;">26</td>
|
||||
<td style="border: 1px solid black;">4</td>
|
||||
<td style="border: 1px solid black;">104</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p>The reverse degree is <code>1 + 52 + 3 + 104 = 160</code>.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s</code> contains only lowercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,55 @@
|
||||
<p>You are given two integer arrays, <code>nums</code> and <code>cost</code>, of the same size, and an integer <code>k</code>.</p>
|
||||
|
||||
<p>You can divide <code>nums</code> into <span data-keyword="subarray-nonempty">subarrays</span>. The cost of the <code>i<sup>th</sup></code> subarray consisting of elements <code>nums[l..r]</code> is:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>(nums[0] + nums[1] + ... + nums[r] + k * i) * (cost[l] + cost[l + 1] + ... + cost[r])</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>Note</strong> that <code>i</code> represents the order of the subarray: 1 for the first subarray, 2 for the second, and so on.</p>
|
||||
|
||||
<p>Return the <strong>minimum</strong> total cost possible from any valid division.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [3,1,4], cost = [4,6,6], k = 1</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">110</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
The minimum total cost possible can be achieved by dividing <code>nums</code> into subarrays <code>[3, 1]</code> and <code>[4]</code>.
|
||||
|
||||
<ul>
|
||||
<li>The cost of the first subarray <code>[3,1]</code> is <code>(3 + 1 + 1 * 1) * (4 + 6) = 50</code>.</li>
|
||||
<li>The cost of the second subarray <code>[4]</code> is <code>(3 + 1 + 4 + 1 * 2) * 6 = 60</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [4,8,5,1,14,2,2,12,1], cost = [7,2,8,4,2,2,1,1,2], k = 7</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 985</p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
The minimum total cost possible can be achieved by dividing <code>nums</code> into subarrays <code>[4, 8, 5, 1]</code>, <code>[14, 2, 2]</code>, and <code>[12, 1]</code>.
|
||||
|
||||
<ul>
|
||||
<li>The cost of the first subarray <code>[4, 8, 5, 1]</code> is <code>(4 + 8 + 5 + 1 + 7 * 1) * (7 + 2 + 8 + 4) = 525</code>.</li>
|
||||
<li>The cost of the second subarray <code>[14, 2, 2]</code> is <code>(4 + 8 + 5 + 1 + 14 + 2 + 2 + 7 * 2) * (2 + 2 + 1) = 250</code>.</li>
|
||||
<li>The cost of the third subarray <code>[12, 1]</code> is <code>(4 + 8 + 5 + 1 + 14 + 2 + 2 + 12 + 1 + 7 * 3) * (1 + 2) = 210</code>.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 1000</code></li>
|
||||
<li><code>cost.length == nums.length</code></li>
|
||||
<li><code>1 <= nums[i], cost[i] <= 1000</code></li>
|
||||
<li><code>1 <= k <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,58 @@
|
||||
<p>You are given a 2D integer array <code>properties</code> having dimensions <code>n x m</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>Define a function <code>intersect(a, b)</code> that returns the <strong>number of distinct integers</strong> common to both arrays <code>a</code> and <code>b</code>.</p>
|
||||
|
||||
<p>Construct an <strong>undirected</strong> graph where each index <code>i</code> corresponds to <code>properties[i]</code>. There is an edge between node <code>i</code> and node <code>j</code> if and only if <code>intersect(properties[i], properties[j]) >= k</code>, where <code>i</code> and <code>j</code> are in the range <code>[0, n - 1]</code> and <code>i != j</code>.</p>
|
||||
|
||||
<p>Return the number of <strong>connected components</strong> in the resulting graph.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">properties = [[1,2],[1,1],[3,4],[4,5],[5,6],[7,7]], k = 1</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">3</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The graph formed has 3 connected components:</p>
|
||||
|
||||
<p><img height="171" src="https://assets.leetcode.com/uploads/2025/02/27/image.png" width="279" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">properties = [[1,2,3],[2,3,4],[4,3,5]], k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">1</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The graph formed has 1 connected component:</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2025/02/27/screenshot-from-2025-02-27-23-58-34.png" style="width: 219px; height: 171px;" /></p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">properties = [[1,1],[1,1]], k = 2</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><code>intersect(properties[0], properties[1]) = 1</code>, which is less than <code>k</code>. This means there is no edge between <code>properties[0]</code> and <code>properties[1]</code> in the graph.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == properties.length <= 100</code></li>
|
||||
<li><code>1 <= m == properties[i].length <= 100</code></li>
|
||||
<li><code>1 <= properties[i][j] <= 100</code></li>
|
||||
<li><code>1 <= k <= m</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,86 @@
|
||||
<p>You are given a binary string <code>s</code> of length <code>n</code>, where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>'1'</code> represents an <strong>active</strong> section.</li>
|
||||
<li><code>'0'</code> represents an <strong>inactive</strong> section.</li>
|
||||
</ul>
|
||||
|
||||
<p>You can perform <strong>at most one trade</strong> to maximize the number of active sections in <code>s</code>. In a trade, you:</p>
|
||||
|
||||
<ul>
|
||||
<li>Convert a contiguous block of <code>'1'</code>s that is surrounded by <code>'0'</code>s to all <code>'0'</code>s.</li>
|
||||
<li>Afterward, convert a contiguous block of <code>'0'</code>s that is surrounded by <code>'1'</code>s to all <code>'1'</code>s.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return the <strong>maximum</strong> number of active sections in <code>s</code> after making the optimal trade.</p>
|
||||
|
||||
<p><strong>Note:</strong> Treat <code>s</code> as if it is <strong>augmented</strong> with a <code>'1'</code> at both ends, forming <code>t = '1' + s + '1'</code>. The augmented <code>'1'</code>s <strong>do not</strong> contribute to the final count.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "01"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">1</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Because there is no block of <code>'1'</code>s surrounded by <code>'0'</code>s, no valid trade is possible. The maximum number of active sections is 1.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "0100"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>String <code>"0100"</code> → Augmented to <code>"101001"</code>.</li>
|
||||
<li>Choose <code>"0100"</code>, convert <code>"10<u><strong>1</strong></u>001"</code> → <code>"1<u><strong>0000</strong></u>1"</code> → <code>"1<u><strong>1111</strong></u>1"</code>.</li>
|
||||
<li>The final string without augmentation is <code>"1111"</code>. The maximum number of active sections is 4.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "1000100"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">7</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>String <code>"1000100"</code> → Augmented to <code>"110001001"</code>.</li>
|
||||
<li>Choose <code>"000100"</code>, convert <code>"11000<u><strong>1</strong></u>001"</code> → <code>"11<u><strong>000000</strong></u>1"</code> → <code>"11<u><strong>111111</strong></u>1"</code>.</li>
|
||||
<li>The final string without augmentation is <code>"1111111"</code>. The maximum number of active sections is 7.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 4:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "01010"</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>String <code>"01010"</code> → Augmented to <code>"1010101"</code>.</li>
|
||||
<li>Choose <code>"010"</code>, convert <code>"10<u><strong>1</strong></u>0101"</code> → <code>"1<u><strong>000</strong></u>101"</code> → <code>"1<u><strong>111</strong></u>101"</code>.</li>
|
||||
<li>The final string without augmentation is <code>"11110"</code>. The maximum number of active sections is 4.</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s[i]</code> is either <code>'0'</code> or <code>'1'</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,135 @@
|
||||
<p>You are given a binary string <code>s</code> of length <code>n</code>, where:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>'1'</code> represents an <strong>active</strong> section.</li>
|
||||
<li><code>'0'</code> represents an <strong>inactive</strong> section.</li>
|
||||
</ul>
|
||||
|
||||
<p>You can perform <strong>at most one trade</strong> to maximize the number of active sections in <code>s</code>. In a trade, you:</p>
|
||||
|
||||
<ul>
|
||||
<li>Convert a contiguous block of <code>'1'</code>s that is surrounded by <code>'0'</code>s to all <code>'0'</code>s.</li>
|
||||
<li>Afterward, convert a contiguous block of <code>'0'</code>s that is surrounded by <code>'1'</code>s to all <code>'1'</code>s.</li>
|
||||
</ul>
|
||||
|
||||
<p>Additionally, you are given a <strong>2D array</strong> <code>queries</code>, where <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>]</code> represents a <span data-keyword="substring-nonempty">substring</span> <code>s[l<sub>i</sub>...r<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>For each query, determine the <strong>maximum</strong> possible number of active sections in <code>s</code> after making the optimal trade on the substring <code>s[l<sub>i</sub>...r<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>Return an array <code>answer</code>, where <code>answer[i]</code> is the result for <code>queries[i]</code>.</p>
|
||||
|
||||
<p><strong>Note</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>For each query, treat <code>s[l<sub>i</sub>...r<sub>i</sub>]</code> as if it is <strong>augmented</strong> with a <code>'1'</code> at both ends, forming <code>t = '1' + s[l<sub>i</sub>...r<sub>i</sub>] + '1'</code>. The augmented <code>'1'</code>s <strong>do not</strong> contribute to the final count.</li>
|
||||
<li>The queries are independent of each other.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "01", queries = [[0,1]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[1]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Because there is no block of <code>'1'</code>s surrounded by <code>'0'</code>s, no valid trade is possible. The maximum number of active sections is 1.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "0100", queries = [[0,3],[0,2],[1,3],[2,3]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[4,3,1,1]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>
|
||||
<p>Query <code>[0, 3]</code> → Substring <code>"0100"</code> → Augmented to <code>"101001"</code><br />
|
||||
Choose <code>"0100"</code>, convert <code>"0100"</code> → <code>"0000"</code> → <code>"1111"</code>.<br />
|
||||
The final string without augmentation is <code>"1111"</code>. The maximum number of active sections is 4.</p>
|
||||
</li>
|
||||
<li>
|
||||
<p>Query <code>[0, 2]</code> → Substring <code>"010"</code> → Augmented to <code>"10101"</code><br />
|
||||
Choose <code>"010"</code>, convert <code>"010"</code> → <code>"000"</code> → <code>"111"</code>.<br />
|
||||
The final string without augmentation is <code>"1110"</code>. The maximum number of active sections is 3.</p>
|
||||
</li>
|
||||
<li>
|
||||
<p>Query <code>[1, 3]</code> → Substring <code>"100"</code> → Augmented to <code>"11001"</code><br />
|
||||
Because there is no block of <code>'1'</code>s surrounded by <code>'0'</code>s, no valid trade is possible. The maximum number of active sections is 1.</p>
|
||||
</li>
|
||||
<li>
|
||||
<p>Query <code>[2, 3]</code> → Substring <code>"00"</code> → Augmented to <code>"1001"</code><br />
|
||||
Because there is no block of <code>'1'</code>s surrounded by <code>'0'</code>s, no valid trade is possible. The maximum number of active sections is 1.</p>
|
||||
</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "1000100", queries = [[1,5],[0,6],[0,4]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[6,7,2]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li data-end="383" data-start="217">
|
||||
<p data-end="383" data-start="219">Query <code>[1, 5]</code> → Substring <code data-end="255" data-start="246">"00010"</code> → Augmented to <code data-end="282" data-start="271">"1000101"</code><br data-end="285" data-start="282" />
|
||||
Choose <code data-end="303" data-start="294">"00010"</code>, convert <code data-end="322" data-start="313">"00010"</code> → <code data-end="322" data-start="313">"00000"</code> → <code data-end="334" data-start="325">"11111"</code>.<br />
|
||||
The final string without augmentation is <code data-end="404" data-start="396">"1111110"</code>. The maximum number of active sections is 6.</p>
|
||||
</li>
|
||||
<li data-end="561" data-start="385">
|
||||
<p data-end="561" data-start="387">Query <code>[0, 6]</code> → Substring <code data-end="425" data-start="414">"1000100"</code> → Augmented to <code data-end="454" data-start="441">"110001001"</code><br data-end="457" data-start="454" />
|
||||
Choose <code data-end="477" data-start="466">"000100"</code>, convert <code data-end="498" data-start="487">"000100"</code> → <code data-end="498" data-start="487">"000000"</code> → <code data-end="512" data-start="501">"111111"</code>.<br />
|
||||
The final string without augmentation is <code data-end="404" data-start="396">"1111111"</code>. The maximum number of active sections is 7.</p>
|
||||
</li>
|
||||
<li data-end="741" data-start="563">
|
||||
<p data-end="741" data-start="565">Query <code>[0, 4]</code> → Substring <code data-end="601" data-start="592">"10001"</code> → Augmented to <code data-end="627" data-start="617">"1100011"</code><br data-end="630" data-start="627" />
|
||||
Because there is no block of <code>'1'</code>s surrounded by <code>'0'</code>s, no valid trade is possible. The maximum number of active sections is 2.</p>
|
||||
</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 4:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">s = "01010", queries = [[0,3],[1,4],[1,3]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[4,4,2]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>
|
||||
<p>Query <code>[0, 3]</code> → Substring <code>"0101"</code> → Augmented to <code>"101011"</code><br />
|
||||
Choose <code>"010"</code>, convert <code>"010"</code> → <code>"000"</code> → <code>"111"</code>.<br />
|
||||
The final string without augmentation is <code>"11110"</code>. The maximum number of active sections is 4.</p>
|
||||
</li>
|
||||
<li>
|
||||
<p>Query <code>[1, 4]</code> → Substring <code>"1010"</code> → Augmented to <code>"110101"</code><br />
|
||||
Choose <code>"010"</code>, convert <code>"010"</code> → <code>"000"</code> → <code>"111"</code>.<br />
|
||||
The final string without augmentation is <code>"01111"</code>. The maximum number of active sections is 4.</p>
|
||||
</li>
|
||||
<li>
|
||||
<p>Query <code>[1, 3]</code> → Substring <code>"101"</code> → Augmented to <code>"11011"</code><br />
|
||||
Because there is no block of <code>'1'</code>s surrounded by <code>'0'</code>s, no valid trade is possible. The maximum number of active sections is 2.</p>
|
||||
</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == s.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= queries.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>s[i]</code> is either <code>'0'</code> or <code>'1'</code>.</li>
|
||||
<li><code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>]</code></li>
|
||||
<li><code>0 <= l<sub>i</sub> <= r<sub>i</sub> < n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>You are given an undirected tree rooted at node <code>0</code>, with <code>n</code> nodes numbered from <code>0</code> to <code>n - 1</code>. This is represented by a 2D array <code>edges</code> of length <code>n - 1</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> indicates an edge between nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with length <code>length<sub>i</sub></code>. You are also given an integer array <code>nums</code>, where <code>nums[i]</code> represents the value at node <code>i</code>.</p>
|
||||
|
||||
<p>A <strong>special path</strong> is defined as a <strong>downward</strong> path from an ancestor node to a descendant node in which all node values are <strong>distinct</strong>, except for <strong>at most</strong> one value that may appear twice.</p>
|
||||
|
||||
<p>Return an array <code data-stringify-type="code">result</code> of size 2, where <code>result[0]</code> is the <b data-stringify-type="bold">length</b> of the <strong>longest</strong> special path, and <code>result[1]</code> is the <b data-stringify-type="bold">minimum</b> number of nodes in all <i data-stringify-type="italic">possible</i> <strong>longest</strong> special paths.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">edges = [[0,1,1],[1,2,3],[1,3,1],[2,4,6],[4,7,2],[3,5,2],[3,6,5],[6,8,3]], nums = [1,1,0,3,1,2,1,1,0]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[9,3]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>In the image below, nodes are colored by their corresponding values in <code>nums</code>.</p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2025/02/18/e1.png" style="width: 190px; height: 270px;" /></p>
|
||||
|
||||
<p>The longest special paths are <code>1 -> 2 -> 4</code> and <code>1 -> 3 -> 6 -> 8</code>, both having a length of 9. The minimum number of nodes across all longest special paths is 3.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">edges = [[1,0,3],[0,2,4],[0,3,5]], nums = [1,1,0,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[5,2]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2025/02/18/e2.png" style="width: 150px; height: 110px;" /></p>
|
||||
|
||||
<p>The longest path is <code>0 -> 3</code> consisting of 2 nodes with a length of 5.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 5 * 10<sup><span style="font-size: 10.8333px;">4</span></sup></code></li>
|
||||
<li><code>edges.length == n - 1</code></li>
|
||||
<li><code>edges[i].length == 3</code></li>
|
||||
<li><code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code></li>
|
||||
<li><code>1 <= length<sub>i</sub> <= 10<sup>3</sup></code></li>
|
||||
<li><code>nums.length == n</code></li>
|
||||
<li><code>0 <= nums[i] <= 5 * 10<sup>4</sup></code></li>
|
||||
<li>The input is generated such that <code>edges</code> represents a valid tree.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p data-end="387" data-start="189">You are given two positive integers, <code><font face="monospace">l</font></code> and <code><font face="monospace">r</font></code>. A positive integer is called <strong data-end="276" data-start="263">beautiful</strong> if the product of its digits is divisible by the sum of its digits.</p>
|
||||
|
||||
<p data-end="529" data-start="448">Return the count of <strong>beautiful</strong> numbers between <code>l</code> and <code>r</code>, inclusive.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">l = 10, r = 20</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The beautiful numbers in the range are 10 and 20.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">l = 1, r = 15</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">10</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>The beautiful numbers in the range are 1, 2, 3, 4, 5, 6, 7, 8, 9, and 10.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= l <= r < 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given a positive integer <code>n</code> representing an <code>n x n</code> cargo deck on a ship. Each cell on the deck can hold one container with a weight of <strong>exactly</strong> <code>w</code>.</p>
|
||||
|
||||
<p>However, the total weight of all containers, if loaded onto the deck, must not exceed the ship's maximum weight capacity, <code>maxWeight</code>.</p>
|
||||
|
||||
<p>Return the <strong>maximum</strong> number of containers that can be loaded onto the ship.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">n = 2, w = 3, maxWeight = 15</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 4</p>
|
||||
|
||||
<p><strong>Explanation: </strong></p>
|
||||
|
||||
<p>The deck has 4 cells, and each container weighs 3. The total weight of loading all containers is 12, which does not exceed <code>maxWeight</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">n = 3, w = 5, maxWeight = 20</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation: </strong></p>
|
||||
|
||||
<p>The deck has 9 cells, and each container weighs 5. The maximum number of containers that can be loaded without exceeding <code>maxWeight</code> is 4.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
<li><code>1 <= w <= 1000</code></li>
|
||||
<li><code>1 <= maxWeight <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,44 @@
|
||||
<p>A spreadsheet is a grid with 26 columns (labeled from <code>'A'</code> to <code>'Z'</code>) and a given number of <code>rows</code>. Each cell in the spreadsheet can hold an integer value between 0 and 10<sup>5</sup>.</p>
|
||||
|
||||
<p>Implement the <code>Spreadsheet</code> class:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>Spreadsheet(int rows)</code> Initializes a spreadsheet with 26 columns (labeled <code>'A'</code> to <code>'Z'</code>) and the specified number of rows. All cells are initially set to 0.</li>
|
||||
<li><code>void setCell(String cell, int value)</code> Sets the value of the specified <code>cell</code>. The cell reference is provided in the format <code>"AX"</code> (e.g., <code>"A1"</code>, <code>"B10"</code>), where the letter represents the column (from <code>'A'</code> to <code>'Z'</code>) and the number represents a <strong>1-indexed</strong> row.</li>
|
||||
<li><code>void resetCell(String cell)</code> Resets the specified cell to 0.</li>
|
||||
<li><code>int getValue(String formula)</code> Evaluates a formula of the form <code>"=X+Y"</code>, where <code>X</code> and <code>Y</code> are <strong>either</strong> cell references or non-negative integers, and returns the computed sum.</li>
|
||||
</ul>
|
||||
|
||||
<p><strong>Note:</strong> If <code>getValue</code> references a cell that has not been explicitly set using <code>setCell</code>, its value is considered 0.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong><br />
|
||||
<span class="example-io">["Spreadsheet", "getValue", "setCell", "getValue", "setCell", "getValue", "resetCell", "getValue"]<br />
|
||||
[[3], ["=5+7"], ["A1", 10], ["=A1+6"], ["B2", 15], ["=A1+B2"], ["A1"], ["=A1+B2"]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong><br />
|
||||
<span class="example-io">[null, 12, null, 16, null, 25, null, 15] </span></p>
|
||||
|
||||
<p><strong>Explanation</strong></p>
|
||||
Spreadsheet spreadsheet = new Spreadsheet(3); // Initializes a spreadsheet with 3 rows and 26 columns<br data-end="321" data-start="318" />
|
||||
spreadsheet.getValue("=5+7"); // returns 12 (5+7)<br data-end="373" data-start="370" />
|
||||
spreadsheet.setCell("A1", 10); // sets A1 to 10<br data-end="423" data-start="420" />
|
||||
spreadsheet.getValue("=A1+6"); // returns 16 (10+6)<br data-end="477" data-start="474" />
|
||||
spreadsheet.setCell("B2", 15); // sets B2 to 15<br data-end="527" data-start="524" />
|
||||
spreadsheet.getValue("=A1+B2"); // returns 25 (10+15)<br data-end="583" data-start="580" />
|
||||
spreadsheet.resetCell("A1"); // resets A1 to 0<br data-end="634" data-start="631" />
|
||||
spreadsheet.getValue("=A1+B2"); // returns 15 (0+15)</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= rows <= 10<sup>3</sup></code></li>
|
||||
<li><code>0 <= value <= 10<sup>5</sup></code></li>
|
||||
<li>The formula is always in the format <code>"=X+Y"</code>, where <code>X</code> and <code>Y</code> are either valid cell references or <strong>non-negative</strong> integers with values less than or equal to <code>10<sup>5</sup></code>.</li>
|
||||
<li>Each cell reference consists of a capital letter from <code>'A'</code> to <code>'Z'</code> followed by a row number between <code>1</code> and <code>rows</code>.</li>
|
||||
<li>At most <code>10<sup>4</sup></code> calls will be made in <strong>total</strong> to <code>setCell</code>, <code>resetCell</code>, and <code>getValue</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>You are given a <strong>circular</strong> array <code>nums</code> and an array <code>queries</code>.</p>
|
||||
|
||||
<p>For each query <code>i</code>, you have to find the following:</p>
|
||||
|
||||
<ul>
|
||||
<li>The <strong>minimum</strong> distance between the element at index <code>queries[i]</code> and <strong>any</strong> other index <code>j</code> in the <strong>circular</strong> array, where <code>nums[j] == nums[queries[i]]</code>. If no such index exists, the answer for that query should be -1.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return an array <code>answer</code> of the <strong>same</strong> size as <code>queries</code>, where <code>answer[i]</code> represents the result for query <code>i</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,3,1,4,1,3,2], queries = [0,3,5]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[2,-1,3]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>Query 0: The element at <code>queries[0] = 0</code> is <code>nums[0] = 1</code>. The nearest index with the same value is 2, and the distance between them is 2.</li>
|
||||
<li>Query 1: The element at <code>queries[1] = 3</code> is <code>nums[3] = 4</code>. No other index contains 4, so the result is -1.</li>
|
||||
<li>Query 2: The element at <code>queries[2] = 5</code> is <code>nums[5] = 3</code>. The nearest index with the same value is 1, and the distance between them is 3 (following the circular path: <code>5 -> 6 -> 0 -> 1</code>).</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,2,3,4], queries = [0,1,2,3]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">[-1,-1,-1,-1]</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>Each value in <code>nums</code> is unique, so no index shares the same value as the queried element. This results in -1 for all queries.</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= queries.length <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>0 <= queries[i] < nums.length</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,99 @@
|
||||
<p>You are given two integer arrays, <code>skill</code> and <code><font face="monospace">mana</font></code>, of length <code>n</code> and <code>m</code>, respectively.</p>
|
||||
|
||||
<p>In a laboratory, <code>n</code> wizards must brew <code>m</code> potions <em>in order</em>. Each potion has a mana capacity <code>mana[j]</code> and <strong>must</strong> pass through <strong>all</strong> the wizards sequentially to be brewed properly. The time taken by the <code>i<sup>th</sup></code> wizard on the <code>j<sup>th</sup></code> potion is <code>time<sub>ij</sub> = skill[i] * mana[j]</code>.</p>
|
||||
|
||||
<p>Since the brewing process is delicate, a potion <strong>must</strong> be passed to the next wizard immediately after the current wizard completes their work. This means the timing must be <em>synchronized</em> so that each wizard begins working on a potion <strong>exactly</strong> when it arrives. </p>
|
||||
|
||||
<p>Return the <strong>minimum</strong> amount of time required for the potions to be brewed properly.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">skill = [1,5,2,4], mana = [5,1,4,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">110</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<table style="border: 1px solid black;">
|
||||
<tbody>
|
||||
<tr>
|
||||
<th style="border: 1px solid black;">Potion Number</th>
|
||||
<th style="border: 1px solid black;">Start time</th>
|
||||
<th style="border: 1px solid black;">Wizard 0 done by</th>
|
||||
<th style="border: 1px solid black;">Wizard 1 done by</th>
|
||||
<th style="border: 1px solid black;">Wizard 2 done by</th>
|
||||
<th style="border: 1px solid black;">Wizard 3 done by</th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;">0</td>
|
||||
<td style="border: 1px solid black;">0</td>
|
||||
<td style="border: 1px solid black;">5</td>
|
||||
<td style="border: 1px solid black;">30</td>
|
||||
<td style="border: 1px solid black;">40</td>
|
||||
<td style="border: 1px solid black;">60</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;">1</td>
|
||||
<td style="border: 1px solid black;">52</td>
|
||||
<td style="border: 1px solid black;">53</td>
|
||||
<td style="border: 1px solid black;">58</td>
|
||||
<td style="border: 1px solid black;">60</td>
|
||||
<td style="border: 1px solid black;">64</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;">2</td>
|
||||
<td style="border: 1px solid black;">54</td>
|
||||
<td style="border: 1px solid black;">58</td>
|
||||
<td style="border: 1px solid black;">78</td>
|
||||
<td style="border: 1px solid black;">86</td>
|
||||
<td style="border: 1px solid black;">102</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="border: 1px solid black;">3</td>
|
||||
<td style="border: 1px solid black;">86</td>
|
||||
<td style="border: 1px solid black;">88</td>
|
||||
<td style="border: 1px solid black;">98</td>
|
||||
<td style="border: 1px solid black;">102</td>
|
||||
<td style="border: 1px solid black;">110</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<p>As an example for why wizard 0 cannot start working on the 1<sup>st</sup> potion before time <code>t = 52</code>, consider the case where the wizards started preparing the 1<sup>st</sup> potion at time <code>t = 50</code>. At time <code>t = 58</code>, wizard 2 is done with the 1<sup>st</sup> potion, but wizard 3 will still be working on the 0<sup>th</sup> potion till time <code>t = 60</code>.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">skill = [1,1,1], mana = [1,1,1]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">5</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ol>
|
||||
<li>Preparation of the 0<sup>th</sup> potion begins at time <code>t = 0</code>, and is completed by time <code>t = 3</code>.</li>
|
||||
<li>Preparation of the 1<sup>st</sup> potion begins at time <code>t = 1</code>, and is completed by time <code>t = 4</code>.</li>
|
||||
<li>Preparation of the 2<sup>nd</sup> potion begins at time <code>t = 2</code>, and is completed by time <code>t = 5</code>.</li>
|
||||
</ol>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">skill = [1,2,3,4], mana = [1,2]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> 21</p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == skill.length</code></li>
|
||||
<li><code>m == mana.length</code></li>
|
||||
<li><code>1 <= n, m <= 5000</code></li>
|
||||
<li><code>1 <= mana[i], skill[i] <= 5000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,109 @@
|
||||
<p>You are given an integer array <code>nums</code> of length <code>n</code> and a 2D array <code>queries</code>, where <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>, val<sub>i</sub>]</code>.</p>
|
||||
|
||||
<p>Each <code>queries[i]</code> represents the following action on <code>nums</code>:</p>
|
||||
|
||||
<ul>
|
||||
<li>Select a <span data-keyword="subset">subset</span> of indices in the range <code>[l<sub>i</sub>, r<sub>i</sub>]</code> from <code>nums</code>.</li>
|
||||
<li>Decrement the value at each selected index by <strong>exactly</strong> <code>val<sub>i</sub></code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>A <strong>Zero Array</strong> is an array with all its elements equal to 0.</p>
|
||||
|
||||
<p>Return the <strong>minimum</strong> possible <strong>non-negative</strong> value of <code>k</code>, such that after processing the first <code>k</code> queries in <strong>sequence</strong>, <code>nums</code> becomes a <strong>Zero Array</strong>. If no such <code>k</code> exists, return -1.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [2,0,2], queries = [[0,2,1],[0,2,1],[1,1,3]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">2</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><strong>For query 0 (l = 0, r = 2, val = 1):</strong>
|
||||
|
||||
<ul>
|
||||
<li>Decrement the values at indices <code>[0, 2]</code> by 1.</li>
|
||||
<li>The array will become <code>[1, 0, 1]</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><strong>For query 1 (l = 0, r = 2, val = 1):</strong>
|
||||
<ul>
|
||||
<li>Decrement the values at indices <code>[0, 2]</code> by 1.</li>
|
||||
<li>The array will become <code>[0, 0, 0]</code>, which is a Zero Array. Therefore, the minimum value of <code>k</code> is 2.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [4,3,2,1], queries = [[1,3,2],[0,2,1]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">-1</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<p>It is impossible to make nums a Zero Array even after all the queries.</p>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,2,3,2,1], queries = [[0,1,1],[1,2,1],[2,3,2],[3,4,1],[4,4,1]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
|
||||
<p><strong>Explanation:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><strong>For query 0 (l = 0, r = 1, val = 1):</strong>
|
||||
|
||||
<ul>
|
||||
<li>Decrement the values at indices <code>[0, 1]</code> by <code><font face="monospace">1</font></code>.</li>
|
||||
<li>The array will become <code>[0, 1, 3, 2, 1]</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><strong>For query 1 (l = 1, r = 2, val = 1):</strong>
|
||||
<ul>
|
||||
<li>Decrement the values at indices <code>[1, 2]</code> by 1.</li>
|
||||
<li>The array will become <code>[0, 0, 2, 2, 1]</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><strong>For query 2 (l = 2, r = 3, val = 2):</strong>
|
||||
<ul>
|
||||
<li>Decrement the values at indices <code>[2, 3]</code> by 2.</li>
|
||||
<li>The array will become <code>[0, 0, 0, 0, 1]</code>.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><strong>For query 3 (l = 3, r = 4, val = 1):</strong>
|
||||
<ul>
|
||||
<li>Decrement the value at index 4 by 1.</li>
|
||||
<li>The array will become <code>[0, 0, 0, 0, 0]</code>. Therefore, the minimum value of <code>k</code> is 4.</li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
<p><strong class="example">Example 4:</strong></p>
|
||||
|
||||
<div class="example-block">
|
||||
<p><strong>Input:</strong> <span class="example-io">nums = [1,2,3,2,6], queries = [[0,1,1],[0,2,1],[1,4,2],[4,4,4],[3,4,1],[4,4,5]]</span></p>
|
||||
|
||||
<p><strong>Output:</strong> <span class="example-io">4</span></p>
|
||||
</div>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10</code></li>
|
||||
<li><code>0 <= nums[i] <= 1000</code></li>
|
||||
<li><code>1 <= queries.length <= 1000</code></li>
|
||||
<li><code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>, val<sub>i</sub>]</code></li>
|
||||
<li><code>0 <= l<sub>i</sub> <= r<sub>i</sub> < nums.length</code></li>
|
||||
<li><code>1 <= val<sub>i</sub> <= 10</code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user