mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-04 23:11:41 +08:00
update
This commit is contained in:
zhangbk1
@@ -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