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
File diff suppressed because one or more lines are too long
180
leetcode/originData/find-if-array-can-be-sorted.json
Normal file
180
leetcode/originData/find-if-array-can-be-sorted.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
180
leetcode/originData/minimum-number-of-pushes-to-type-word-i.json
Normal file
180
leetcode/originData/minimum-number-of-pushes-to-type-word-i.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
@@ -0,0 +1,56 @@
|
||||
<p>You are given three <strong>positive</strong> integers <code>n</code>, <code>x</code>, and <code>y</code>.</p>
|
||||
|
||||
<p>In a city, there exist houses numbered <code>1</code> to <code>n</code> connected by <code>n</code> streets. There is a street connecting the house numbered <code>i</code> with the house numbered <code>i + 1</code> for all <code>1 <= i <= n - 1</code> . An additional street connects the house numbered <code>x</code> with the house numbered <code>y</code>.</p>
|
||||
|
||||
<p>For each <code>k</code>, such that <code>1 <= k <= n</code>, you need to find the number of <strong>pairs of houses</strong> <code>(house<sub>1</sub>, house<sub>2</sub>)</code> such that the <strong>minimum</strong> number of streets that need to be traveled to reach <code>house<sub>2</sub></code> from <code>house<sub>1</sub></code> is <code>k</code>.</p>
|
||||
|
||||
<p>Return <em>a <strong>1-indexed</strong> array </em><code>result</code><em> of length </em><code>n</code><em> where </em><code>result[k]</code><em> represents the <strong>total</strong> number of pairs of houses such that the <strong>minimum</strong> streets required to reach one house from the other is </em><code>k</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that <code>x</code> and <code>y</code> can be <strong>equal</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/20/example2.png" style="width: 474px; height: 197px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, x = 1, y = 3
|
||||
<strong>Output:</strong> [6,0,0]
|
||||
<strong>Explanation:</strong> Let's look at each pair of houses:
|
||||
- For the pair (1, 2), we can go from house 1 to house 2 directly.
|
||||
- For the pair (2, 1), we can go from house 2 to house 1 directly.
|
||||
- For the pair (1, 3), we can go from house 1 to house 3 directly.
|
||||
- For the pair (3, 1), we can go from house 3 to house 1 directly.
|
||||
- For the pair (2, 3), we can go from house 2 to house 3 directly.
|
||||
- For the pair (3, 2), we can go from house 3 to house 2 directly.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/20/example3.png" style="width: 668px; height: 174px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, x = 2, y = 4
|
||||
<strong>Output:</strong> [10,8,2,0,0]
|
||||
<strong>Explanation:</strong> For each distance k the pairs are:
|
||||
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (2, 4), (4, 2), (3, 4), (4, 3), (4, 5), and (5, 4).
|
||||
- For k == 2, the pairs are (1, 3), (3, 1), (1, 4), (4, 1), (2, 5), (5, 2), (3, 5), and (5, 3).
|
||||
- For k == 3, the pairs are (1, 5), and (5, 1).
|
||||
- For k == 4 and k == 5, there are no pairs.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/20/example5.png" style="width: 544px; height: 130px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, x = 1, y = 1
|
||||
<strong>Output:</strong> [6,4,2,0]
|
||||
<strong>Explanation:</strong> For each distance k the pairs are:
|
||||
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), and (4, 3).
|
||||
- For k == 2, the pairs are (1, 3), (3, 1), (2, 4), and (4, 2).
|
||||
- For k == 3, the pairs are (1, 4), and (4, 1).
|
||||
- For k == 4, there are no pairs.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 100</code></li>
|
||||
<li><code>1 <= x, y <= n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,56 @@
|
||||
<p>You are given three <strong>positive</strong> integers <code>n</code>, <code>x</code>, and <code>y</code>.</p>
|
||||
|
||||
<p>In a city, there exist houses numbered <code>1</code> to <code>n</code> connected by <code>n</code> streets. There is a street connecting the house numbered <code>i</code> with the house numbered <code>i + 1</code> for all <code>1 <= i <= n - 1</code> . An additional street connects the house numbered <code>x</code> with the house numbered <code>y</code>.</p>
|
||||
|
||||
<p>For each <code>k</code>, such that <code>1 <= k <= n</code>, you need to find the number of <strong>pairs of houses</strong> <code>(house<sub>1</sub>, house<sub>2</sub>)</code> such that the <strong>minimum</strong> number of streets that need to be traveled to reach <code>house<sub>2</sub></code> from <code>house<sub>1</sub></code> is <code>k</code>.</p>
|
||||
|
||||
<p>Return <em>a <strong>1-indexed</strong> array </em><code>result</code><em> of length </em><code>n</code><em> where </em><code>result[k]</code><em> represents the <strong>total</strong> number of pairs of houses such that the <strong>minimum</strong> streets required to reach one house from the other is </em><code>k</code>.</p>
|
||||
|
||||
<p><strong>Note</strong> that <code>x</code> and <code>y</code> can be <strong>equal</strong>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/20/example2.png" style="width: 474px; height: 197px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, x = 1, y = 3
|
||||
<strong>Output:</strong> [6,0,0]
|
||||
<strong>Explanation:</strong> Let's look at each pair of houses:
|
||||
- For the pair (1, 2), we can go from house 1 to house 2 directly.
|
||||
- For the pair (2, 1), we can go from house 2 to house 1 directly.
|
||||
- For the pair (1, 3), we can go from house 1 to house 3 directly.
|
||||
- For the pair (3, 1), we can go from house 3 to house 1 directly.
|
||||
- For the pair (2, 3), we can go from house 2 to house 3 directly.
|
||||
- For the pair (3, 2), we can go from house 3 to house 2 directly.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/20/example3.png" style="width: 668px; height: 174px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, x = 2, y = 4
|
||||
<strong>Output:</strong> [10,8,2,0,0]
|
||||
<strong>Explanation:</strong> For each distance k the pairs are:
|
||||
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (2, 4), (4, 2), (3, 4), (4, 3), (4, 5), and (5, 4).
|
||||
- For k == 2, the pairs are (1, 3), (3, 1), (1, 4), (4, 1), (2, 5), (5, 2), (3, 5), and (5, 3).
|
||||
- For k == 3, the pairs are (1, 5), and (5, 1).
|
||||
- For k == 4 and k == 5, there are no pairs.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/20/example5.png" style="width: 544px; height: 130px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, x = 1, y = 1
|
||||
<strong>Output:</strong> [6,4,2,0]
|
||||
<strong>Explanation:</strong> For each distance k the pairs are:
|
||||
- For k == 1, the pairs are (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), and (4, 3).
|
||||
- For k == 2, the pairs are (1, 3), (3, 1), (2, 4), and (4, 2).
|
||||
- For k == 3, the pairs are (1, 4), and (4, 1).
|
||||
- For k == 4, there are no pairs.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= x, y <= n</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,45 @@
|
||||
<p>You are given an array of integers <code>nums</code> of length <code>n</code>.</p>
|
||||
|
||||
<p>The <strong>cost</strong> of an array is the value of its <strong>first</strong> element. For example, the cost of <code>[1,2,3]</code> is <code>1</code> while the cost of <code>[3,4,1]</code> is <code>3</code>.</p>
|
||||
|
||||
<p>You need to divide <code>nums</code> into <code>3</code> <strong>disjoint contiguous </strong><span data-keyword="subarray-nonempty">subarrays</span>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> possible <strong>sum</strong> of the cost of these subarrays</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,12]
|
||||
<strong>Output:</strong> 6
|
||||
<strong>Explanation:</strong> The best possible way to form 3 subarrays is: [1], [2], and [3,12] at a total cost of 1 + 2 + 3 = 6.
|
||||
The other possible ways to form 3 subarrays are:
|
||||
- [1], [2,3], and [12] at a total cost of 1 + 2 + 12 = 15.
|
||||
- [1,2], [3], and [12] at a total cost of 1 + 3 + 12 = 16.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,4,3]
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> The best possible way to form 3 subarrays is: [5], [4], and [3] at a total cost of 5 + 4 + 3 = 12.
|
||||
It can be shown that 12 is the minimum cost achievable.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,3,1,1]
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> The best possible way to form 3 subarrays is: [10,3], [1], and [1] at a total cost of 10 + 1 + 1 = 12.
|
||||
It can be shown that 12 is the minimum cost achievable.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>3 <= n <= 50</code></li>
|
||||
<li><code>1 <= nums[i] <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,47 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array of integers <code>nums</code> of length <code>n</code>, and two <strong>positive</strong> integers <code>k</code> and <code>dist</code>.</p>
|
||||
|
||||
<p>The <strong>cost</strong> of an array is the value of its <strong>first</strong> element. For example, the cost of <code>[1,2,3]</code> is <code>1</code> while the cost of <code>[3,4,1]</code> is <code>3</code>.</p>
|
||||
|
||||
<p>You need to divide <code>nums</code> into <code>k</code> <strong>disjoint contiguous </strong><span data-keyword="subarray-nonempty">subarrays</span>, such that the difference between the starting index of the <strong>second</strong> subarray and the starting index of the <code>kth</code> subarray should be <strong>less than or equal to</strong> <code>dist</code>. In other words, if you divide <code>nums</code> into the subarrays <code>nums[0..(i<sub>1</sub> - 1)], nums[i<sub>1</sub>..(i<sub>2</sub> - 1)], ..., nums[i<sub>k-1</sub>..(n - 1)]</code>, then <code>i<sub>k-1</sub> - i<sub>1</sub> <= dist</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> possible sum of the cost of these</em> <em>subarrays</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,3,2,6,4,2], k = 3, dist = 3
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The best possible way to divide nums into 3 subarrays is: [1,3], [2,6,4], and [2]. This choice is valid because i<sub>k-1</sub> - i<sub>1</sub> is 5 - 2 = 3 which is equal to dist. The total cost is nums[0] + nums[2] + nums[5] which is 1 + 2 + 2 = 5.
|
||||
It can be shown that there is no possible way to divide nums into 3 subarrays at a cost lower than 5.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,1,2,2,2,1], k = 4, dist = 3
|
||||
<strong>Output:</strong> 15
|
||||
<strong>Explanation:</strong> The best possible way to divide nums into 4 subarrays is: [10], [1], [2], and [2,2,1]. This choice is valid because i<sub>k-1</sub> - i<sub>1</sub> is 3 - 1 = 2 which is less than dist. The total cost is nums[0] + nums[1] + nums[2] + nums[3] which is 10 + 1 + 2 + 2 = 15.
|
||||
The division [10], [1], [2,2,2], and [1] is not valid, because the difference between i<sub>k-1</sub> and i<sub>1</sub> is 5 - 1 = 4, which is greater than dist.
|
||||
It can be shown that there is no possible way to divide nums into 4 subarrays at a cost lower than 15.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [10,8,18,9], k = 3, dist = 1
|
||||
<strong>Output:</strong> 36
|
||||
<strong>Explanation:</strong> The best possible way to divide nums into 4 subarrays is: [10], [8], and [18,9]. This choice is valid because i<sub>k-1</sub> - i<sub>1</sub> is 2 - 1 = 1 which is equal to dist.The total cost is nums[0] + nums[1] + nums[2] which is 10 + 8 + 18 = 36.
|
||||
The division [10], [8,18], and [9] is not valid, because the difference between i<sub>k-1</sub> and i<sub>1</sub> is 3 - 1 = 2, which is greater than dist.
|
||||
It can be shown that there is no possible way to divide nums into 3 subarrays at a cost lower than 36.
|
||||
</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>
|
||||
<li><code>3 <= k <= n</code></li>
|
||||
<li><code>k - 2 <= dist <= n - 2</code></li>
|
||||
</ul>
|
||||
45
leetcode/problem/find-if-array-can-be-sorted.html
Normal file
45
leetcode/problem/find-if-array-can-be-sorted.html
Normal file
@@ -0,0 +1,45 @@
|
||||
<p>You are given a <strong>0-indexed</strong> array of <strong>positive</strong> integers <code>nums</code>.</p>
|
||||
|
||||
<p>In one <strong>operation</strong>, you can swap any two <strong>adjacent</strong> elements if they have the <strong>same</strong> number of <span data-keyword="set-bit">set bits</span>. You are allowed to do this operation <strong>any</strong> number of times (<strong>including zero</strong>).</p>
|
||||
|
||||
<p>Return <code>true</code> <em>if you can sort the array, else return </em><code>false</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [8,4,2,30,15]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> Let's look at the binary representation of every element. The numbers 2, 4, and 8 have one set bit each with binary representation "10", "100", and "1000" respectively. The numbers 15 and 30 have four set bits each with binary representation "1111" and "11110".
|
||||
We can sort the array using 4 operations:
|
||||
- Swap nums[0] with nums[1]. This operation is valid because 8 and 4 have one set bit each. The array becomes [4,8,2,30,15].
|
||||
- Swap nums[1] with nums[2]. This operation is valid because 8 and 2 have one set bit each. The array becomes [4,2,8,30,15].
|
||||
- Swap nums[0] with nums[1]. This operation is valid because 4 and 2 have one set bit each. The array becomes [2,4,8,30,15].
|
||||
- Swap nums[3] with nums[4]. This operation is valid because 30 and 15 have four set bits each. The array becomes [2,4,8,15,30].
|
||||
The array has become sorted, hence we return true.
|
||||
Note that there may be other sequences of operations which also sort the array.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,2,3,4,5]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> The array is already sorted, hence we return true.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,16,8,4,2]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> It can be shown that it is not possible to sort the input array using any number of operations.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 100</code></li>
|
||||
<li><code>1 <= nums[i] <= 2<sup>8</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,63 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> containing <strong>positive</strong> integers.</p>
|
||||
|
||||
<p>Your task is to <strong>minimize</strong> the length of <code>nums</code> by performing the following operations <strong>any</strong> number of times (including zero):</p>
|
||||
|
||||
<ul>
|
||||
<li>Select <strong>two</strong> <strong>distinct</strong> indices <code>i</code> and <code>j</code> from <code>nums</code>, such that <code>nums[i] > 0</code> and <code>nums[j] > 0</code>.</li>
|
||||
<li>Insert the result of <code>nums[i] % nums[j]</code> at the end of <code>nums</code>.</li>
|
||||
<li>Delete the elements at indices <code>i</code> and <code>j</code> from <code>nums</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>an integer denoting the <strong>minimum</strong> <strong>length</strong> of </em><code>nums</code><em> after performing the operation any number of times.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [1,4,3,1]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> One way to minimize the length of the array is as follows:
|
||||
Operation 1: Select indices 2 and 1, insert nums[2] % nums[1] at the end and it becomes [1,4,3,1,3], then delete elements at indices 2 and 1.
|
||||
nums becomes [1,1,3].
|
||||
Operation 2: Select indices 1 and 2, insert nums[1] % nums[2] at the end and it becomes [1,1,3,1], then delete elements at indices 1 and 2.
|
||||
nums becomes [1,1].
|
||||
Operation 3: Select indices 1 and 0, insert nums[1] % nums[0] at the end and it becomes [1,1,0], then delete elements at indices 1 and 0.
|
||||
nums becomes [0].
|
||||
The length of nums cannot be reduced further. Hence, the answer is 1.
|
||||
It can be shown that 1 is the minimum achievable length. </pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [5,5,5,10,5]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> One way to minimize the length of the array is as follows:
|
||||
Operation 1: Select indices 0 and 3, insert nums[0] % nums[3] at the end and it becomes [5,5,5,10,5,5], then delete elements at indices 0 and 3.
|
||||
nums becomes [5,5,5,5].
|
||||
Operation 2: Select indices 2 and 3, insert nums[2] % nums[3] at the end and it becomes [5,5,5,5,0], then delete elements at indices 2 and 3.
|
||||
nums becomes [5,5,0].
|
||||
Operation 3: Select indices 0 and 1, insert nums[0] % nums[1] at the end and it becomes [5,5,0,0], then delete elements at indices 0 and 1.
|
||||
nums becomes [0,0].
|
||||
The length of nums cannot be reduced further. Hence, the answer is 2.
|
||||
It can be shown that 2 is the minimum achievable length. </pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,3,4]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> One way to minimize the length of the array is as follows:
|
||||
Operation 1: Select indices 1 and 2, insert nums[1] % nums[2] at the end and it becomes [2,3,4,3], then delete elements at indices 1 and 2.
|
||||
nums becomes [2,3].
|
||||
Operation 2: Select indices 1 and 0, insert nums[1] % nums[0] at the end and it becomes [2,3,1], then delete elements at indices 1 and 0.
|
||||
nums becomes [1].
|
||||
The length of nums cannot be reduced further. Hence, the answer is 1.
|
||||
It can be shown that 1 is the minimum achievable length.</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 a string <code>word</code> containing <strong>distinct</strong> lowercase English letters.</p>
|
||||
|
||||
<p>Telephone keypads have keys mapped with <strong>distinct</strong> collections of lowercase English letters, which can be used to form words by pushing them. For example, the key <code>2</code> is mapped with <code>["a","b","c"]</code>, we need to push the key one time to type <code>"a"</code>, two times to type <code>"b"</code>, and three times to type <code>"c"</code> <em>.</em></p>
|
||||
|
||||
<p>It is allowed to remap the keys numbered <code>2</code> to <code>9</code> to <strong>distinct</strong> collections of letters. The keys can be remapped to <strong>any</strong> amount of letters, but each letter <strong>must</strong> be mapped to <strong>exactly</strong> one key. You need to find the <strong>minimum</strong> number of times the keys will be pushed to type the string <code>word</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of pushes needed to type </em><code>word</code> <em>after remapping the keys</em>.</p>
|
||||
|
||||
<p>An example mapping of letters to keys on a telephone keypad is given below. Note that <code>1</code>, <code>*</code>, <code>#</code>, and <code>0</code> do <strong>not</strong> map to any letters.</p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/26/keypaddesc.png" style="width: 329px; height: 313px;" />
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/26/keypadv1e1.png" style="width: 329px; height: 313px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "abcde"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The remapped keypad given in the image provides the minimum cost.
|
||||
"a" -> one push on key 2
|
||||
"b" -> one push on key 3
|
||||
"c" -> one push on key 4
|
||||
"d" -> one push on key 5
|
||||
"e" -> one push on key 6
|
||||
Total cost is 1 + 1 + 1 + 1 + 1 = 5.
|
||||
It can be shown that no other mapping can provide a lower cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/26/keypadv1e2.png" style="width: 329px; height: 313px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "xycdefghij"
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> The remapped keypad given in the image provides the minimum cost.
|
||||
"x" -> one push on key 2
|
||||
"y" -> two pushes on key 2
|
||||
"c" -> one push on key 3
|
||||
"d" -> two pushes on key 3
|
||||
"e" -> one push on key 4
|
||||
"f" -> one push on key 5
|
||||
"g" -> one push on key 6
|
||||
"h" -> one push on key 7
|
||||
"i" -> one push on key 8
|
||||
"j" -> one push on key 9
|
||||
Total cost is 1 + 2 + 1 + 2 + 1 + 1 + 1 + 1 + 1 + 1 = 12.
|
||||
It can be shown that no other mapping can provide a lower cost.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= word.length <= 26</code></li>
|
||||
<li><code>word</code> consists of lowercase English letters.</li>
|
||||
<li>All letters in <code>word</code> are distinct.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,66 @@
|
||||
<p>You are given a string <code>word</code> containing lowercase English letters.</p>
|
||||
|
||||
<p>Telephone keypads have keys mapped with <strong>distinct</strong> collections of lowercase English letters, which can be used to form words by pushing them. For example, the key <code>2</code> is mapped with <code>["a","b","c"]</code>, we need to push the key one time to type <code>"a"</code>, two times to type <code>"b"</code>, and three times to type <code>"c"</code> <em>.</em></p>
|
||||
|
||||
<p>It is allowed to remap the keys numbered <code>2</code> to <code>9</code> to <strong>distinct</strong> collections of letters. The keys can be remapped to <strong>any</strong> amount of letters, but each letter <strong>must</strong> be mapped to <strong>exactly</strong> one key. You need to find the <strong>minimum</strong> number of times the keys will be pushed to type the string <code>word</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of pushes needed to type </em><code>word</code> <em>after remapping the keys</em>.</p>
|
||||
|
||||
<p>An example mapping of letters to keys on a telephone keypad is given below. Note that <code>1</code>, <code>*</code>, <code>#</code>, and <code>0</code> do <strong>not</strong> map to any letters.</p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/26/keypaddesc.png" style="width: 329px; height: 313px;" />
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/26/keypadv1e1.png" style="width: 329px; height: 313px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "abcde"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> The remapped keypad given in the image provides the minimum cost.
|
||||
"a" -> one push on key 2
|
||||
"b" -> one push on key 3
|
||||
"c" -> one push on key 4
|
||||
"d" -> one push on key 5
|
||||
"e" -> one push on key 6
|
||||
Total cost is 1 + 1 + 1 + 1 + 1 = 5.
|
||||
It can be shown that no other mapping can provide a lower cost.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/26/keypadv2e2.png" style="width: 329px; height: 313px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "xyzxyzxyzxyz"
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong> The remapped keypad given in the image provides the minimum cost.
|
||||
"x" -> one push on key 2
|
||||
"y" -> one push on key 3
|
||||
"z" -> one push on key 4
|
||||
Total cost is 1 * 4 + 1 * 4 + 1 * 4 = 12
|
||||
It can be shown that no other mapping can provide a lower cost.
|
||||
Note that the key 9 is not mapped to any letter: it is not necessary to map letters to every key, but to map all the letters.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/12/27/keypadv2.png" style="width: 329px; height: 313px;" />
|
||||
<pre>
|
||||
<strong>Input:</strong> word = "aabbccddeeffgghhiiiiii"
|
||||
<strong>Output:</strong> 24
|
||||
<strong>Explanation:</strong> The remapped keypad given in the image provides the minimum cost.
|
||||
"a" -> one push on key 2
|
||||
"b" -> one push on key 3
|
||||
"c" -> one push on key 4
|
||||
"d" -> one push on key 5
|
||||
"e" -> one push on key 6
|
||||
"f" -> one push on key 7
|
||||
"g" -> one push on key 8
|
||||
"h" -> two pushes on key 9
|
||||
"i" -> one push on key 9
|
||||
Total cost is 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 1 * 2 + 2 * 2 + 6 * 1 = 24.
|
||||
It can be shown that no other mapping can provide a lower cost.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= word.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>word</code> consists of lowercase English letters.</li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user