mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-03 14:32:54 +08:00
update
This commit is contained in:
zhangbk1
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
187
leetcode/originData/count-the-number-of-good-partitions.json
Normal file
187
leetcode/originData/count-the-number-of-good-partitions.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
177
leetcode/originData/double-modular-exponentiation.json
Normal file
177
leetcode/originData/double-modular-exponentiation.json
Normal file
File diff suppressed because one or more lines are too long
174
leetcode/originData/find-common-elements-between-two-arrays.json
Normal file
174
leetcode/originData/find-common-elements-between-two-arrays.json
Normal file
File diff suppressed because one or more lines are too long
158
leetcode/originData/find-missing-and-repeated-values.json
Normal file
158
leetcode/originData/find-missing-and-repeated-values.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
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
180
leetcode/originData/remove-adjacent-almost-equal-characters.json
Normal file
180
leetcode/originData/remove-adjacent-almost-equal-characters.json
Normal file
File diff suppressed because one or more lines are too long
@@ -0,0 +1,44 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>You can perform the following operation on the array <strong>at most</strong> <code>k</code> times:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose any index <code>i</code> from the array and <strong>increase</strong> or <strong>decrease</strong> <code>nums[i]</code> by <code>1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>The score of the final array is the <strong>frequency</strong> of the most frequent element in the array.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> score you can achieve</em>.</p>
|
||||
|
||||
<p>The frequency of an element is the number of occurences of that element in the array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,6,4], k = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can do the following operations on the array:
|
||||
- Choose i = 0, and increase the value of nums[0] by 1. The resulting array is [2,2,6,4].
|
||||
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,3].
|
||||
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,2].
|
||||
The element 2 is the most frequent in the final array so our score is 3.
|
||||
It can be shown that we cannot achieve a better score.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,4,2,4], k = 0
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We cannot apply any operations so our score will be the frequency of the most frequent element in the original array, which is 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
<li><code>0 <= k <= 10<sup>14</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>You are given an integer array <code>nums</code> and a <strong>positive</strong> integer <code>k</code>.</p>
|
||||
|
||||
<p>Return <em>the number of subarrays where the <strong>maximum</strong> element of </em><code>nums</code><em> appears <strong>at least</strong> </em><code>k</code><em> times in that subarray.</em></p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous sequence of elements within an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,2,3,3], k = 2
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The subarrays that contain the element 3 at least 2 times are: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] and [3,3].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,2,1], k = 3
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> No subarray contains the element 4 at least 3 times.
|
||||
</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>6</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>batteryPercentages</code> having length <code>n</code>, denoting the battery percentages of <code>n</code> <strong>0-indexed</strong> devices.</p>
|
||||
|
||||
<p>Your task is to test each device <code>i</code> <strong>in order</strong> from <code>0</code> to <code>n - 1</code>, by performing the following test operations:</p>
|
||||
|
||||
<ul>
|
||||
<li>If <code>batteryPercentages[i]</code> is <strong>greater</strong> than <code>0</code>:
|
||||
|
||||
<ul>
|
||||
<li><strong>Increment</strong> the count of tested devices.</li>
|
||||
<li><strong>Decrease</strong> the battery percentage of all devices with indices <code>j</code> in the range <code>[i + 1, n - 1]</code> by <code>1</code>, ensuring their battery percentage <strong>never goes below</strong> <code>0</code>, i.e, <code>batteryPercentages[j] = max(0, batteryPercentages[j] - 1)</code>.</li>
|
||||
<li>Move to the next device.</li>
|
||||
</ul>
|
||||
</li>
|
||||
<li>Otherwise, move to the next device without performing any test.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer denoting the number of devices that will be tested after performing the test operations in order.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> batteryPercentages = [1,1,2,1,3]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation: </strong>Performing the test operations in order starting from device 0:
|
||||
At device 0, batteryPercentages[0] > 0, so there is now 1 tested device, and batteryPercentages becomes [1,0,1,0,2].
|
||||
At device 1, batteryPercentages[1] == 0, so we move to the next device without testing.
|
||||
At device 2, batteryPercentages[2] > 0, so there are now 2 tested devices, and batteryPercentages becomes [1,0,1,0,1].
|
||||
At device 3, batteryPercentages[3] == 0, so we move to the next device without testing.
|
||||
At device 4, batteryPercentages[4] > 0, so there are now 3 tested devices, and batteryPercentages stays the same.
|
||||
So, the answer is 3.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> batteryPercentages = [0,1,2]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Performing the test operations in order starting from device 0:
|
||||
At device 0, batteryPercentages[0] == 0, so we move to the next device without testing.
|
||||
At device 1, batteryPercentages[1] > 0, so there is now 1 tested device, and batteryPercentages becomes [0,1,1].
|
||||
At device 2, batteryPercentages[2] > 0, so there are now 2 tested devices, and batteryPercentages stays the same.
|
||||
So, the answer is 2.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n == batteryPercentages.length <= 100 </code></li>
|
||||
<li><code>0 <= batteryPercentages[i] <= 100</code></li>
|
||||
</ul>
|
||||
40
leetcode/problem/count-the-number-of-good-partitions.html
Normal file
40
leetcode/problem/count-the-number-of-good-partitions.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array <code>nums</code> consisting of <strong>positive</strong> integers.</p>
|
||||
|
||||
<p>A partition of an array into one or more <strong>contiguous</strong> subarrays is called <strong>good</strong> if no two subarrays contain the same number.</p>
|
||||
|
||||
<p>Return <em>the <strong>total number</strong> of good partitions of </em><code>nums</code>.</p>
|
||||
|
||||
<p>Since the answer may be large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4]
|
||||
<strong>Output:</strong> 8
|
||||
<strong>Explanation:</strong> The 8 possible good partitions are: ([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]), and ([1,2,3,4]).
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,1,1,1]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> The only possible good partition is: ([1,1,1,1]).
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,3]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The 2 possible good partitions are: ([1,2,1], [3]) and ([1,2,1,3]).
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given an integer array <code>nums</code> of size <code>n</code> and a positive integer <code>k</code>.</p>
|
||||
|
||||
<p>Divide the array into one or more arrays of size <code>3</code> satisfying the following conditions:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>Each</strong> element of <code>nums</code> should be in <strong>exactly</strong> one array.</li>
|
||||
<li>The difference between <strong>any</strong> two elements in one array is less than or equal to <code>k</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>a </em><strong>2D</strong><em> array containing all the arrays. If it is impossible to satisfy the conditions, return an empty array. And if there are multiple answers, return <strong>any</strong> of them.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,4,8,7,9,3,5,1], k = 2
|
||||
<strong>Output:</strong> [[1,1,3],[3,4,5],[7,8,9]]
|
||||
<strong>Explanation:</strong> We can divide the array into the following arrays: [1,1,3], [3,4,5] and [7,8,9].
|
||||
The difference between any two elements in each array is less than or equal to 2.
|
||||
Note that the order of elements is not important.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,3,2,7,3], k = 3
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> It is not possible to divide the array satisfying all the conditions.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>n</code> is a multiple of <code>3</code>.</li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= k <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
43
leetcode/problem/double-modular-exponentiation.html
Normal file
43
leetcode/problem/double-modular-exponentiation.html
Normal file
@@ -0,0 +1,43 @@
|
||||
<p>You are given a <strong>0-indexed</strong> 2D array <code>variables</code> where <code>variables[i] = [a<sub>i</sub>, b<sub>i</sub>, c<sub>i,</sub> m<sub>i</sub>]</code>, and an integer <code>target</code>.</p>
|
||||
|
||||
<p>An index <code>i</code> is <strong>good</strong> if the following formula holds:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= i < variables.length</code></li>
|
||||
<li><code>((a<sub>i</sub><sup>b<sub>i</sub></sup> % 10)<sup>c<sub>i</sub></sup>) % m<sub>i</sub> == target</code></li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array consisting of <strong>good</strong> indices in <strong>any order</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
|
||||
<strong>Output:</strong> [0,2]
|
||||
<strong>Explanation:</strong> For each index i in the variables array:
|
||||
1) For the index 0, variables[0] = [2,3,3,10], (2<sup>3</sup> % 10)<sup>3</sup> % 10 = 2.
|
||||
2) For the index 1, variables[1] = [3,3,3,1], (3<sup>3</sup> % 10)<sup>3</sup> % 1 = 0.
|
||||
3) For the index 2, variables[2] = [6,1,1,4], (6<sup>1</sup> % 10)<sup>1</sup> % 4 = 2.
|
||||
Therefore we return [0,2] as the answer.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> variables = [[39,3,1000,1000]], target = 17
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> For each index i in the variables array:
|
||||
1) For the index 0, variables[0] = [39,3,1000,1000], (39<sup>3</sup> % 10)<sup>1000</sup> % 1000 = 1.
|
||||
Therefore we return [] as the answer.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= variables.length <= 100</code></li>
|
||||
<li><code>variables[i] == [a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub>, m<sub>i</sub>]</code></li>
|
||||
<li><code>1 <= a<sub>i</sub>, b<sub>i</sub>, c<sub>i</sub>, m<sub>i</sub> <= 10<sup>3</sup></code></li>
|
||||
<li><code><font face="monospace">0 <= target <= 10<sup>3</sup></font></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,39 @@
|
||||
<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code> of sizes <code>n</code> and <code>m</code>, respectively.</p>
|
||||
|
||||
<p>Consider calculating the following values:</p>
|
||||
|
||||
<ul>
|
||||
<li>The number of indices <code>i</code> such that <code>0 <= i < n</code> and <code>nums1[i]</code> occurs <strong>at least</strong> once in <code>nums2</code>.</li>
|
||||
<li>The number of indices <code>i</code> such that <code>0 <= i < m</code> and <code>nums2[i]</code> occurs <strong>at least</strong> once in <code>nums1</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer array </em><code>answer</code><em> of size </em><code>2</code><em> containing the two values <strong>in the above order</strong></em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
|
||||
<strong>Output:</strong> [3,4]
|
||||
<strong>Explanation:</strong> We calculate the values as follows:
|
||||
- The elements at indices 1, 2, and 3 in nums1 occur at least once in nums2. So the first value is 3.
|
||||
- The elements at indices 0, 1, 3, and 4 in nums2 occur at least once in nums1. So the second value is 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums1 = [3,4,2,3], nums2 = [1,5]
|
||||
<strong>Output:</strong> [0,0]
|
||||
<strong>Explanation:</strong> There are no common elements between the two arrays, so the two values will be 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums1.length</code></li>
|
||||
<li><code>m == nums2.length</code></li>
|
||||
<li><code>1 <= n, m <= 100</code></li>
|
||||
<li><code>1 <= nums1[i], nums2[i] <= 100</code></li>
|
||||
</ul>
|
||||
31
leetcode/problem/find-missing-and-repeated-values.html
Normal file
31
leetcode/problem/find-missing-and-repeated-values.html
Normal file
@@ -0,0 +1,31 @@
|
||||
<p>You are given a <strong>0-indexed</strong> 2D integer matrix <code><font face="monospace">grid</font></code> of size <code>n * n</code> with values in the range <code>[1, n<sup>2</sup>]</code>. Each integer appears <strong>exactly once</strong> except <code>a</code> which appears <strong>twice</strong> and <code>b</code> which is <strong>missing</strong>. The task is to find the repeating and missing numbers <code>a</code> and <code>b</code>.</p>
|
||||
|
||||
<p>Return <em>a <strong>0-indexed </strong>integer array </em><code>ans</code><em> of size </em><code>2</code><em> where </em><code>ans[0]</code><em> equals to </em><code>a</code><em> and </em><code>ans[1]</code><em> equals to </em><code>b</code><em>.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1,3],[2,2]]
|
||||
<strong>Output:</strong> [2,4]
|
||||
<strong>Explanation:</strong> Number 2 is repeated and number 4 is missing so the answer is [2,4].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[9,1,7],[8,9,2],[3,4,6]]
|
||||
<strong>Output:</strong> [9,5]
|
||||
<strong>Explanation:</strong> Number 9 is repeated and number 5 is missing so the answer is [9,5].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n == grid.length == grid[i].length <= 50</code></li>
|
||||
<li><code>1 <= grid[i][j] <= n * n</code></li>
|
||||
<li>For all <code>x</code> that <code>1 <= x <= n * n</code> there is exactly one <code>x</code> that is not equal to any of the grid members.</li>
|
||||
<li>For all <code>x</code> that <code>1 <= x <= n * n</code> there is exactly one <code>x</code> that is equal to exactly two of the grid members.</li>
|
||||
<li>For all <code>x</code> that <code>1 <= x <= n * n</code> except two of them there is exatly one pair of <code>i, j</code> that <code>0 <= i, j <= n - 1</code> and <code>grid[i][j] == x</code>.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,46 @@
|
||||
<p>You are given an integer array <code>nums</code> and an integer <code>k</code>.</p>
|
||||
|
||||
<p>The <strong>frequency</strong> of an element <code>x</code> is the number of times it occurs in an array.</p>
|
||||
|
||||
<p>An array is called <strong>good</strong> if the frequency of each element in this array is <strong>less than or equal</strong> to <code>k</code>.</p>
|
||||
|
||||
<p>Return <em>the length of the <strong>longest</strong> <strong>good</strong> subarray of</em> <code>nums</code><em>.</em></p>
|
||||
|
||||
<p>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,1,2,3,1,2], k = 2
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The longest possible good subarray is [1,2,3,1,2,3] since the values 1, 2, and 3 occur at most twice in this subarray. Note that the subarrays [2,3,1,2,3,1] and [3,1,2,3,1,2] are also good.
|
||||
It can be shown that there are no good subarrays with length more than 6.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,1,2,1,2,1,2], k = 1
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The longest possible good subarray is [1,2] since the values 1 and 2 occur at most once in this subarray. Note that the subarray [2,1] is also good.
|
||||
It can be shown that there are no good subarrays with length more than 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,5,5,5,5,5,5], k = 4
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The longest possible good subarray is [5,5,5,5] since the value 5 occurs 4 times in this subarray.
|
||||
It can be shown that there are no good subarrays with length more than 4.
|
||||
</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</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,51 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> having length <code>n</code>.</p>
|
||||
|
||||
<p>You are allowed to perform a special move <strong>any</strong> number of times (<strong>including zero</strong>) on <code>nums</code>. In one <strong>special</strong> <strong>move</strong> you perform the following steps <strong>in order</strong>:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose an index <code>i</code> in the range <code>[0, n - 1]</code>, and a <strong>positive</strong> integer <code>x</code>.</li>
|
||||
<li>Add <code>|nums[i] - x|</code> to the total cost.</li>
|
||||
<li>Change the value of <code>nums[i]</code> to <code>x</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>A <strong>palindromic number</strong> is a positive integer that remains the same when its digits are reversed. For example, <code>121</code>, <code>2552</code> and <code>65756</code> are palindromic numbers whereas <code>24</code>, <code>46</code>, <code>235</code> are not palindromic numbers.</p>
|
||||
|
||||
<p>An array is considered <strong>equalindromic</strong> if all the elements in the array are equal to an integer <code>y</code>, where <code>y</code> is a <strong>palindromic number</strong> less than <code>10<sup>9</sup></code>.</p>
|
||||
|
||||
<p>Return <em>an integer denoting the <strong>minimum</strong> possible total cost to make </em><code>nums</code><em> <strong>equalindromic</strong> by performing any number of special moves.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,5]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> We can make the array equalindromic by changing all elements to 3 which is a palindromic number. The cost of changing the array to [3,3,3,3,3] using 4 special moves is given by |1 - 3| + |2 - 3| + |4 - 3| + |5 - 3| = 6.
|
||||
It can be shown that changing all elements to any palindromic number other than 3 cannot be achieved at a lower cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,12,13,14,15]
|
||||
<strong>Output:</strong> 11
|
||||
<strong>Explanation:</strong> We can make the array equalindromic by changing all elements to 11 which is a palindromic number. The cost of changing the array to [11,11,11,11,11] using 5 special moves is given by |10 - 11| + |12 - 11| + |13 - 11| + |14 - 11| + |15 - 11| = 11.
|
||||
It can be shown that changing all elements to any palindromic number other than 11 cannot be achieved at a lower cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [22,33,22,33,22]
|
||||
<strong>Output:</strong> 22
|
||||
<strong>Explanation:</strong> We can make the array equalindromic by changing all elements to 22 which is a palindromic number. The cost of changing the array to [22,22,22,22,22] using 2 special moves is given by |33 - 22| + |33 - 22| = 22.
|
||||
It can be shown that changing all elements to any palindromic number other than 22 cannot be achieved at a lower cost.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,69 @@
|
||||
<p>There is a company with <code>n</code> branches across the country, some of which are connected by roads. Initially, all branches are reachable from each other by traveling some roads.</p>
|
||||
|
||||
<p>The company has realized that they are spending an excessive amount of time traveling between their branches. As a result, they have decided to close down some of these branches (<strong>possibly none</strong>). However, they want to ensure that the remaining branches have a distance of at most <code>maxDistance</code> from each other.</p>
|
||||
|
||||
<p>The <strong>distance</strong> between two branches is the <strong>minimum</strong> total traveled length needed to reach one branch from another.</p>
|
||||
|
||||
<p>You are given integers <code>n</code>, <code>maxDistance</code>, and a <strong>0-indexed</strong> 2D array <code>roads</code>, where <code>roads[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> represents the <strong>undirected</strong> road between branches <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with length <code>w<sub>i</sub></code>.</p>
|
||||
|
||||
<p>Return <em>the number of possible sets of closing branches, so that any branch has a distance of at most </em><code>maxDistance</code><em> from any other</em>.</p>
|
||||
|
||||
<p><strong>Note</strong> that, after closing a branch, the company will no longer have access to any roads connected to it.</p>
|
||||
|
||||
<p><strong>Note</strong> that, multiple roads are allowed.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/11/08/example11.png" style="width: 221px; height: 191px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, maxDistance = 5, roads = [[0,1,2],[1,2,10],[0,2,10]]
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The possible sets of closing branches are:
|
||||
- The set [2], after closing, active branches are [0,1] and they are reachable to each other within distance 2.
|
||||
- The set [0,1], after closing, the active branch is [2].
|
||||
- The set [1,2], after closing, the active branch is [0].
|
||||
- The set [0,2], after closing, the active branch is [1].
|
||||
- The set [0,1,2], after closing, there are no active branches.
|
||||
It can be proven, that there are only 5 possible sets of closing branches.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/11/08/example22.png" style="width: 221px; height: 241px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, maxDistance = 5, roads = [[0,1,20],[0,1,10],[1,2,2],[0,2,2]]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> The possible sets of closing branches are:
|
||||
- The set [], after closing, active branches are [0,1,2] and they are reachable to each other within distance 4.
|
||||
- The set [0], after closing, active branches are [1,2] and they are reachable to each other within distance 2.
|
||||
- The set [1], after closing, active branches are [0,2] and they are reachable to each other within distance 2.
|
||||
- The set [0,1], after closing, the active branch is [2].
|
||||
- The set [1,2], after closing, the active branch is [0].
|
||||
- The set [0,2], after closing, the active branch is [1].
|
||||
- The set [0,1,2], after closing, there are no active branches.
|
||||
It can be proven, that there are only 7 possible sets of closing branches.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 1, maxDistance = 10, roads = []
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The possible sets of closing branches are:
|
||||
- The set [], after closing, the active branch is [0].
|
||||
- The set [0], after closing, there are no active branches.
|
||||
It can be proven, that there are only 2 possible sets of closing branches.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 10</code></li>
|
||||
<li><code>1 <= maxDistance <= 10<sup>5</sup></code></li>
|
||||
<li><code>0 <= roads.length <= 1000</code></li>
|
||||
<li><code>roads[i].length == 3</code></li>
|
||||
<li><code>0 <= u<sub>i</sub>, v<sub>i</sub> <= n - 1</code></li>
|
||||
<li><code>u<sub>i</sub> != v<sub>i</sub></code></li>
|
||||
<li><code>1 <= w<sub>i</sub> <= 1000</code></li>
|
||||
<li>All branches are reachable from each other by traveling some roads.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,42 @@
|
||||
<p>You are given a <strong>0-indexed</strong> string <code>word</code>.</p>
|
||||
|
||||
<p>In one operation, you can pick any index <code>i</code> of <code>word</code> and change <code>word[i]</code> to any lowercase English letter.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of operations needed to remove all adjacent <strong>almost-equal</strong> characters from</em> <code>word</code>.</p>
|
||||
|
||||
<p>Two characters <code>a</code> and <code>b</code> are <strong>almost-equal</strong> if <code>a == b</code> or <code>a</code> and <code>b</code> are adjacent in the alphabet.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "aaaaa"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We can change word into "a<strong><u>c</u></strong>a<u><strong>c</strong></u>a" which does not have any adjacent almost-equal characters.
|
||||
It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "abddez"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We can change word into "<strong><u>y</u></strong>bd<u><strong>o</strong></u>ez" which does not have any adjacent almost-equal characters.
|
||||
It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 2.</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "zyxyxyz"
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can change word into "z<u><strong>a</strong></u>x<u><strong>a</strong></u>x<strong><u>a</u></strong>z" which does not have any adjacent almost-equal characters.
|
||||
It can be shown that the minimum number of operations needed to remove all adjacent almost-equal characters from word is 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= word.length <= 100</code></li>
|
||||
<li><code>word</code> consists only of lowercase English letters.</li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user