mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-03 06:22:54 +08:00
update
This commit is contained in:
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
52
leetcode/originData/[no content]symmetric-coordinates.json
Normal file
52
leetcode/originData/[no content]symmetric-coordinates.json
Normal file
@@ -0,0 +1,52 @@
|
||||
{
|
||||
"data": {
|
||||
"question": {
|
||||
"questionId": "3253",
|
||||
"questionFrontendId": "2978",
|
||||
"boundTopicId": null,
|
||||
"title": "Symmetric Coordinates",
|
||||
"titleSlug": "symmetric-coordinates",
|
||||
"content": null,
|
||||
"translatedTitle": null,
|
||||
"translatedContent": null,
|
||||
"isPaidOnly": true,
|
||||
"difficulty": "Medium",
|
||||
"likes": 3,
|
||||
"dislikes": 0,
|
||||
"isLiked": null,
|
||||
"similarQuestions": "[]",
|
||||
"exampleTestcases": "{\"headers\":{\"Coordinates\":[\"X\",\"Y\"]},\"rows\":{\"Coordinates\":[[20,20],[20,20],[20,21],[23,22],[22,23],[21,20]]}}",
|
||||
"categoryTitle": "Database",
|
||||
"contributors": [],
|
||||
"topicTags": [],
|
||||
"companyTagStats": null,
|
||||
"codeSnippets": null,
|
||||
"stats": "{\"totalAccepted\": \"124\", \"totalSubmission\": \"227\", \"totalAcceptedRaw\": 124, \"totalSubmissionRaw\": 227, \"acRate\": \"54.6%\"}",
|
||||
"hints": [],
|
||||
"solution": null,
|
||||
"status": null,
|
||||
"sampleTestCase": "{\"headers\":{\"Coordinates\":[\"X\",\"Y\"]},\"rows\":{\"Coordinates\":[[20,20],[20,20],[20,21],[23,22],[22,23],[21,20]]}}",
|
||||
"metaData": "{\"mysql\": [\"Create table If Not Exists Coordinates (X int, Y int)\"], \"mssql\": [\"Create table Coordinates (X int,Y int)\"], \"oraclesql\": [\"Create table Coordinates (X int,Y int)\"], \"database\": true, \"name\": \"symmetric_pairs\", \"pythondata\": [\"Coordinates = pd.DataFrame([], columns=['X', 'Y']).astype({'X':'Int64', 'Y':'Int64'})\"], \"postgresql\": [\"Create table If Not Exists Coordinates (X int, Y int)\"], \"database_schema\": {\"Coordinates\": {\"X\": \"INT\", \"Y\": \"INT\"}}}",
|
||||
"judgerAvailable": true,
|
||||
"judgeType": "large",
|
||||
"mysqlSchemas": [
|
||||
"Create table If Not Exists Coordinates (X int, Y int)",
|
||||
"Truncate table Coordinates",
|
||||
"insert into Coordinates (X, Y) values ('20', '20')",
|
||||
"insert into Coordinates (X, Y) values ('20', '20')",
|
||||
"insert into Coordinates (X, Y) values ('20', '21')",
|
||||
"insert into Coordinates (X, Y) values ('23', '22')",
|
||||
"insert into Coordinates (X, Y) values ('22', '23')",
|
||||
"insert into Coordinates (X, Y) values ('21', '20')"
|
||||
],
|
||||
"enableRunCode": true,
|
||||
"enableTestMode": false,
|
||||
"enableDebugger": false,
|
||||
"envInfo": "{\"mysql\": [\"MySQL\", \"<p><code>MySQL 8.0</code>.</p>\"], \"mssql\": [\"MS SQL Server\", \"<p><code>mssql server 2019</code>.</p>\"], \"oraclesql\": [\"Oracle\", \"<p><code>Oracle Sql 11.2</code>.</p>\"], \"pythondata\": [\"Pandas\", \"<p>Python 3.10 with Pandas 2.0.2 and NumPy 1.25.0</p>\"], \"postgresql\": [\"PostgreSQL\", \"<p>PostgreSQL 16</p>\"]}",
|
||||
"libraryUrl": null,
|
||||
"adminUrl": null,
|
||||
"challengeQuestion": null,
|
||||
"__typename": "QuestionNode"
|
||||
}
|
||||
}
|
||||
}
|
||||
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
162
leetcode/originData/find-polygon-with-the-largest-perimeter.json
Normal file
162
leetcode/originData/find-polygon-with-the-largest-perimeter.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
163
leetcode/originData/minimum-cost-to-convert-string-i.json
Normal file
163
leetcode/originData/minimum-cost-to-convert-string-i.json
Normal file
File diff suppressed because one or more lines are too long
164
leetcode/originData/minimum-cost-to-convert-string-ii.json
Normal file
164
leetcode/originData/minimum-cost-to-convert-string-ii.json
Normal file
File diff suppressed because one or more lines are too long
160
leetcode/originData/minimum-number-game.json
Normal file
160
leetcode/originData/minimum-number-game.json
Normal file
File diff suppressed because one or more lines are too long
@@ -0,0 +1,43 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array of <strong>positive</strong> integers <code>nums</code>.</p>
|
||||
|
||||
<p>A subarray of <code>nums</code> is called <strong>incremovable</strong> if <code>nums</code> becomes <strong>strictly increasing</strong> on removing the subarray. For example, the subarray <code>[3, 4]</code> is an incremovable subarray of <code>[5, 3, 4, 6, 7]</code> because removing this subarray changes the array <code>[5, 3, 4, 6, 7]</code> to <code>[5, 6, 7]</code> which is strictly increasing.</p>
|
||||
|
||||
<p>Return <em>the total number of <strong>incremovable</strong> subarrays of</em> <code>nums</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that an empty array is considered strictly increasing.</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,4]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> The 10 incremovable subarrays are: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4], and [1,2,3,4], because on removing any one of these subarrays nums becomes strictly increasing. Note that you cannot select an empty subarray.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [6,5,7,8]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> The 7 incremovable subarrays are: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] and [6,5,7,8].
|
||||
It can be shown that there are only 7 incremovable subarrays in nums.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [8,7,6,6]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The 3 incremovable subarrays are: [8,7,6], [7,6,6], and [8,7,6,6]. Note that [8,7] is not an incremovable subarray because after removing [8,7] nums becomes [6,6], which is sorted in ascending order but not strictly increasing.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 50</code></li>
|
||||
<li><code>1 <= nums[i] <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,43 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array of <strong>positive</strong> integers <code>nums</code>.</p>
|
||||
|
||||
<p>A subarray of <code>nums</code> is called <strong>incremovable</strong> if <code>nums</code> becomes <strong>strictly increasing</strong> on removing the subarray. For example, the subarray <code>[3, 4]</code> is an incremovable subarray of <code>[5, 3, 4, 6, 7]</code> because removing this subarray changes the array <code>[5, 3, 4, 6, 7]</code> to <code>[5, 6, 7]</code> which is strictly increasing.</p>
|
||||
|
||||
<p>Return <em>the total number of <strong>incremovable</strong> subarrays of</em> <code>nums</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that an empty array is considered strictly increasing.</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,4]
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong> The 10 incremovable subarrays are: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4], and [1,2,3,4], because on removing any one of these subarrays nums becomes strictly increasing. Note that you cannot select an empty subarray.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [6,5,7,8]
|
||||
<strong>Output:</strong> 7
|
||||
<strong>Explanation:</strong> The 7 incremovable subarrays are: [5], [6], [5,7], [6,5], [5,7,8], [6,5,7] and [6,5,7,8].
|
||||
It can be shown that there are only 7 incremovable subarrays in nums.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [8,7,6,6]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> The 3 incremovable subarrays are: [8,7,6], [7,6,6], and [8,7,6,6]. Note that [8,7] is not an incremovable subarray because after removing [8,7] nums becomes [6,6], which is sorted in ascending order but not strictly increasing.
|
||||
</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,54 @@
|
||||
<p>You are given an <strong>undirected</strong> tree with <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>, and rooted at node <code>0</code>. You are given a 2D integer array <code>edges</code> of length <code>n - 1</code>, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.</p>
|
||||
|
||||
<p>You are also given a <strong>0-indexed</strong> integer array <code>cost</code> of length <code>n</code>, where <code>cost[i]</code> is the <strong>cost</strong> assigned to the <code>i<sup>th</sup></code> node.</p>
|
||||
|
||||
<p>You need to place some coins on every node of the tree. The number of coins to be placed at node <code>i</code> can be calculated as:</p>
|
||||
|
||||
<ul>
|
||||
<li>If size of the subtree of node <code>i</code> is less than <code>3</code>, place <code>1</code> coin.</li>
|
||||
<li>Otherwise, place an amount of coins equal to the <strong>maximum</strong> product of cost values assigned to <code>3</code> distinct nodes in the subtree of node <code>i</code>. If this product is <strong>negative</strong>, place <code>0</code> coins.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an array </em><code>coin</code><em> of size </em><code>n</code><em> such that </em><code>coin[i]</code><em> is the number of coins placed at node </em><code>i</code><em>.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/11/09/screenshot-2023-11-10-012641.png" style="width: 600px; height: 233px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> edges = [[0,1],[0,2],[0,3],[0,4],[0,5]], cost = [1,2,3,4,5,6]
|
||||
<strong>Output:</strong> [120,1,1,1,1,1]
|
||||
<strong>Explanation:</strong> For node 0 place 6 * 5 * 4 = 120 coins. All other nodes are leaves with subtree of size 1, place 1 coin on each of them.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/11/09/screenshot-2023-11-10-012614.png" style="width: 800px; height: 374px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> edges = [[0,1],[0,2],[1,3],[1,4],[1,5],[2,6],[2,7],[2,8]], cost = [1,4,2,3,5,7,8,-4,2]
|
||||
<strong>Output:</strong> [280,140,32,1,1,1,1,1,1]
|
||||
<strong>Explanation:</strong> The coins placed on each node are:
|
||||
- Place 8 * 7 * 5 = 280 coins on node 0.
|
||||
- Place 7 * 5 * 4 = 140 coins on node 1.
|
||||
- Place 8 * 2 * 2 = 32 coins on node 2.
|
||||
- All other nodes are leaves with subtree of size 1, place 1 coin on each of them.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/11/09/screenshot-2023-11-10-012513.png" style="width: 300px; height: 277px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> edges = [[0,1],[0,2]], cost = [1,2,-2]
|
||||
<strong>Output:</strong> [0,1,1]
|
||||
<strong>Explanation:</strong> Node 1 and 2 are leaves with subtree of size 1, place 1 coin on each of them. For node 0 the only possible product of cost is 2 * 1 * -2 = -4. Hence place 0 coins on node 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 2 * 10<sup>4</sup></code></li>
|
||||
<li><code>edges.length == n - 1</code></li>
|
||||
<li><code>edges[i].length == 2</code></li>
|
||||
<li><code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code></li>
|
||||
<li><code>cost.length == n</code></li>
|
||||
<li><code>1 <= |cost[i]| <= 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,44 @@
|
||||
<p>You are given an array of <strong>positive</strong> integers <code>nums</code> of length <code>n</code>.</p>
|
||||
|
||||
<p>A <strong>polygon</strong> is a closed plane figure that has at least <code>3</code> sides. The <strong>longest side</strong> of a polygon is <strong>smaller</strong> than the sum of its other sides.</p>
|
||||
|
||||
<p>Conversely, if you have <code>k</code> (<code>k >= 3</code>) <strong>positive</strong> real numbers <code>a<sub>1</sub></code>, <code>a<sub>2</sub></code>, <code>a<sub>3</sub></code>, ..., <code>a<sub>k</sub></code> where <code>a<sub>1</sub> <= a<sub>2</sub> <= a<sub>3</sub> <= ... <= a<sub>k</sub></code> <strong>and</strong> <code>a<sub>1</sub> + a<sub>2</sub> + a<sub>3</sub> + ... + a<sub>k-1</sub> > a<sub>k</sub></code>, then there <strong>always</strong> exists a polygon with <code>k</code> sides whose lengths are <code>a<sub>1</sub></code>, <code>a<sub>2</sub></code>, <code>a<sub>3</sub></code>, ..., <code>a<sub>k</sub></code>.</p>
|
||||
|
||||
<p>The <strong>perimeter</strong> of a polygon is the sum of lengths of its sides.</p>
|
||||
|
||||
<p>Return <em>the <strong>largest</strong> possible <strong>perimeter</strong> of a <strong>polygon</strong> whose sides can be formed from</em> <code>nums</code>, <em>or</em> <code>-1</code> <em>if it is not possible to create a polygon</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,5,5]
|
||||
<strong>Output:</strong> 15
|
||||
<strong>Explanation:</strong> The only possible polygon that can be made from nums has 3 sides: 5, 5, and 5. The perimeter is 5 + 5 + 5 = 15.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,12,1,2,5,50,3]
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> The polygon with the largest perimeter which can be made from nums has 5 sides: 1, 1, 2, 3, and 5. The perimeter is 1 + 1 + 2 + 3 + 5 = 12.
|
||||
We cannot have a polygon with either 12 or 50 as the longest side because it is not possible to include 2 or more smaller sides that have a greater sum than either of them.
|
||||
It can be shown that the largest possible perimeter is 12.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,5,50]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> There is no possible way to form a polygon from nums, as a polygon has at least 3 sides and 50 > 5 + 5.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>9</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>There is a large <code>(m - 1) x (n - 1)</code> rectangular field with corners at <code>(1, 1)</code> and <code>(m, n)</code> containing some horizontal and vertical fences given in arrays <code>hFences</code> and <code>vFences</code> respectively.</p>
|
||||
|
||||
<p>Horizontal fences are from the coordinates <code>(hFences[i], 1)</code> to <code>(hFences[i], n)</code> and vertical fences are from the coordinates <code>(1, vFences[i])</code> to <code>(m, vFences[i])</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>maximum</strong> area of a <strong>square</strong> field that can be formed by <strong>removing</strong> some fences (<strong>possibly none</strong>) or </em><code>-1</code> <em>if it is impossible to make a square field</em>.</p>
|
||||
|
||||
<p>Since the answer may be large, return it <strong>modulo</strong> <code>10<sup>9 </sup>+ 7</code>.</p>
|
||||
|
||||
<p><strong>Note: </strong>The field is surrounded by two horizontal fences from the coordinates <code>(1, 1)</code> to <code>(1, n)</code> and <code>(m, 1)</code> to <code>(m, n)</code> and two vertical fences from the coordinates <code>(1, 1)</code> to <code>(m, 1)</code> and <code>(1, n)</code> to <code>(m, n)</code>. These fences <strong>cannot</strong> be removed.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/11/05/screenshot-from-2023-11-05-22-40-25.png" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> m = 4, n = 3, hFences = [2,3], vFences = [2]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> Removing the horizontal fence at 2 and the vertical fence at 2 will give a square field of area 4.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<p><img alt="" src="https://assets.leetcode.com/uploads/2023/11/22/maxsquareareaexample1.png" style="width: 285px; height: 242px;" /></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> m = 6, n = 7, hFences = [2], vFences = [4]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> It can be proved that there is no way to create a square field by removing fences.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= m, n <= 10<sup>9</sup></code></li>
|
||||
<li><code><font face="monospace">1 <= hF</font>ences<font face="monospace">.length, vFences.length <= 600</font></code></li>
|
||||
<li><code><font face="monospace">1 < hFences[i] < m</font></code></li>
|
||||
<li><code><font face="monospace">1 < vFences[i] < n</font></code></li>
|
||||
<li><code><font face="monospace">hFences</font></code><font face="monospace"> and </font><code><font face="monospace">vFences</font></code><font face="monospace"> are unique.</font></li>
|
||||
</ul>
|
||||
50
leetcode/problem/minimum-cost-to-convert-string-i.html
Normal file
50
leetcode/problem/minimum-cost-to-convert-string-i.html
Normal file
@@ -0,0 +1,50 @@
|
||||
<p>You are given two <strong>0-indexed</strong> strings <code>source</code> and <code>target</code>, both of length <code>n</code> and consisting of <strong>lowercase</strong> English letters. You are also given two <strong>0-indexed</strong> character arrays <code>original</code> and <code>changed</code>, and an integer array <code>cost</code>, where <code>cost[i]</code> represents the cost of changing the character <code>original[i]</code> to the character <code>changed[i]</code>.</p>
|
||||
|
||||
<p>You start with the string <code>source</code>. In one operation, you can pick a character <code>x</code> from the string and change it to the character <code>y</code> at a cost of <code>z</code> <strong>if</strong> there exists <strong>any</strong> index <code>j</code> such that <code>cost[j] == z</code>, <code>original[j] == x</code>, and <code>changed[j] == y</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> cost to convert the string </em><code>source</code><em> to the string </em><code>target</code><em> using <strong>any</strong> number of operations. If it is impossible to convert</em> <code>source</code> <em>to</em> <code>target</code>, <em>return</em> <code>-1</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that there may exist indices <code>i</code>, <code>j</code> such that <code>original[j] == original[i]</code> and <code>changed[j] == changed[i]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
|
||||
<strong>Output:</strong> 28
|
||||
<strong>Explanation:</strong> To convert the string "abcd" to string "acbe":
|
||||
- Change value at index 1 from 'b' to 'c' at a cost of 5.
|
||||
- Change value at index 2 from 'c' to 'e' at a cost of 1.
|
||||
- Change value at index 2 from 'e' to 'b' at a cost of 2.
|
||||
- Change value at index 3 from 'd' to 'e' at a cost of 20.
|
||||
The total cost incurred is 5 + 1 + 2 + 20 = 28.
|
||||
It can be shown that this is the minimum possible cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> To change the character 'a' to 'b' change the character 'a' to 'c' at a cost of 1, followed by changing the character 'c' to 'b' at a cost of 2, for a total cost of 1 + 2 = 3. To change all occurrences of 'a' to 'b', a total cost of 3 * 4 = 12 is incurred.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> It is impossible to convert source to target because the value at index 3 cannot be changed from 'd' to 'e'.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= source.length == target.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>source</code>, <code>target</code> consist of lowercase English letters.</li>
|
||||
<li><code>1 <= cost.length == original.length == changed.length <= 2000</code></li>
|
||||
<li><code>original[i]</code>, <code>changed[i]</code> are lowercase English letters.</li>
|
||||
<li><code>1 <= cost[i] <= 10<sup>6</sup></code></li>
|
||||
<li><code>original[i] != changed[i]</code></li>
|
||||
</ul>
|
||||
63
leetcode/problem/minimum-cost-to-convert-string-ii.html
Normal file
63
leetcode/problem/minimum-cost-to-convert-string-ii.html
Normal file
@@ -0,0 +1,63 @@
|
||||
<p>You are given two <strong>0-indexed</strong> strings <code>source</code> and <code>target</code>, both of length <code>n</code> and consisting of <strong>lowercase</strong> English characters. You are also given two <strong>0-indexed</strong> string arrays <code>original</code> and <code>changed</code>, and an integer array <code>cost</code>, where <code>cost[i]</code> represents the cost of converting the string <code>original[i]</code> to the string <code>changed[i]</code>.</p>
|
||||
|
||||
<p>You start with the string <code>source</code>. In one operation, you can pick a <strong>substring</strong> <code>x</code> from the string, and change it to <code>y</code> at a cost of <code>z</code> <strong>if</strong> there exists <strong>any</strong> index <code>j</code> such that <code>cost[j] == z</code>, <code>original[j] == x</code>, and <code>changed[j] == y</code>. You are allowed to do <strong>any</strong> number of operations, but any pair of operations must satisfy <strong>either</strong> of these two conditions:</p>
|
||||
|
||||
<ul>
|
||||
<li>The substrings picked in the operations are <code>source[a..b]</code> and <code>source[c..d]</code> with either <code>b < c</code> <strong>or</strong> <code>d < a</code>. In other words, the indices picked in both operations are <strong>disjoint</strong>.</li>
|
||||
<li>The substrings picked in the operations are <code>source[a..b]</code> and <code>source[c..d]</code> with <code>a == c</code> <strong>and</strong> <code>b == d</code>. In other words, the indices picked in both operations are <strong>identical</strong>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> cost to convert the string </em><code>source</code><em> to the string </em><code>target</code><em> using <strong>any</strong> number of operations</em>. <em>If it is impossible to convert</em> <code>source</code> <em>to</em> <code>target</code>,<em> return</em> <code>-1</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that there may exist indices <code>i</code>, <code>j</code> such that <code>original[j] == original[i]</code> and <code>changed[j] == changed[i]</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
|
||||
<strong>Output:</strong> 28
|
||||
<strong>Explanation:</strong> To convert "abcd" to "acbe", do the following operations:
|
||||
- Change substring source[1..1] from "b" to "c" at a cost of 5.
|
||||
- Change substring source[2..2] from "c" to "e" at a cost of 1.
|
||||
- Change substring source[2..2] from "e" to "b" at a cost of 2.
|
||||
- Change substring source[3..3] from "d" to "e" at a cost of 20.
|
||||
The total cost incurred is 5 + 1 + 2 + 20 = 28.
|
||||
It can be shown that this is the minimum possible cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> source = "abcdefgh", target = "acdeeghh", original = ["bcd","fgh","thh"], changed = ["cde","thh","ghh"], cost = [1,3,5]
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> To convert "abcdefgh" to "acdeeghh", do the following operations:
|
||||
- Change substring source[1..3] from "bcd" to "cde" at a cost of 1.
|
||||
- Change substring source[5..7] from "fgh" to "thh" at a cost of 3. We can do this operation because indices [5,7] are disjoint with indices picked in the first operation.
|
||||
- Change substring source[5..7] from "thh" to "ghh" at a cost of 5. We can do this operation because indices [5,7] are disjoint with indices picked in the first operation, and identical with indices picked in the second operation.
|
||||
The total cost incurred is 1 + 3 + 5 = 9.
|
||||
It can be shown that this is the minimum possible cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> source = "abcdefgh", target = "addddddd", original = ["bcd","defgh"], changed = ["ddd","ddddd"], cost = [100,1578]
|
||||
<strong>Output:</strong> -1
|
||||
<strong>Explanation:</strong> It is impossible to convert "abcdefgh" to "addddddd".
|
||||
If you select substring source[1..3] as the first operation to change "abcdefgh" to "adddefgh", you cannot select substring source[3..7] as the second operation because it has a common index, 3, with the first operation.
|
||||
If you select substring source[3..7] as the first operation to change "abcdefgh" to "abcddddd", you cannot select substring source[1..3] as the second operation because it has a common index, 3, with the first operation.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= source.length == target.length <= 1000</code></li>
|
||||
<li><code>source</code>, <code>target</code> consist only of lowercase English characters.</li>
|
||||
<li><code>1 <= cost.length == original.length == changed.length <= 100</code></li>
|
||||
<li><code>1 <= original[i].length == changed[i].length <= source.length</code></li>
|
||||
<li><code>original[i]</code>, <code>changed[i]</code> consist only of lowercase English characters.</li>
|
||||
<li><code>original[i] != changed[i]</code></li>
|
||||
<li><code>1 <= cost[i] <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
36
leetcode/problem/minimum-number-game.html
Normal file
36
leetcode/problem/minimum-number-game.html
Normal file
@@ -0,0 +1,36 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> of <strong>even</strong> length and there is also an empty array <code>arr</code>. Alice and Bob decided to play a game where in every round Alice and Bob will do one move. The rules of the game are as follows:</p>
|
||||
|
||||
<ul>
|
||||
<li>Every round, first Alice will remove the <strong>minimum</strong> element from <code>nums</code>, and then Bob does the same.</li>
|
||||
<li>Now, first Bob will append the removed element in the array <code>arr</code>, and then Alice does the same.</li>
|
||||
<li>The game continues until <code>nums</code> becomes empty.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the resulting array </em><code>arr</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,4,2,3]
|
||||
<strong>Output:</strong> [3,2,5,4]
|
||||
<strong>Explanation:</strong> In round one, first Alice removes 2 and then Bob removes 3. Then in arr firstly Bob appends 3 and then Alice appends 2. So arr = [3,2].
|
||||
At the begining of round two, nums = [5,4]. Now, first Alice removes 4 and then Bob removes 5. Then both append in arr which becomes [3,2,5,4].
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,5]
|
||||
<strong>Output:</strong> [5,2]
|
||||
<strong>Explanation:</strong> In round one, first Alice removes 2 and then Bob removes 5. Then in arr firstly Bob appends and then Alice appends. So arr = [5,2].
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 100</code></li>
|
||||
<li><code>nums.length % 2 == 0</code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user