Question

3016. Minimum Number of Pushes to Type Word II

中文文档

Description

You are given a string word containing lowercase English letters.

Telephone keypads have keys mapped with distinct collections of lowercase English letters, which can be used to form words by pushing them. For example, the key 2 is mapped with ["a","b","c"] , we need to push the key one time to type "a" , two times to type "b" , and three times to type "c" _._

It is allowed to remap the keys numbered 2 to 9 to distinct collections of letters. The keys can be remapped to any amount of letters, but each letter must be mapped to exactly one key. You need to find the minimum number of times the keys will be pushed to type the string word .

Return _the minimum number of pushes needed to type _ word _after remapping the keys_.

An example mapping of letters to keys on a telephone keypad is given below. Note that 1 , * , # , and 0 do not map to any letters.

Example 1:

Input: word = "abcde"
Output: 5
Explanation: 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.

Example 2:

Input: word = "xyzxyzxyzxyz"
Output: 12
Explanation: 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.

Example 3:

Input: word = "aabbccddeeffgghhiiiiii"
Output: 24
Explanation: 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.

Constraints:

• 1 <= word.length <= 105
• word consists of lowercase English letters.

Solutions

Solution 1: Greedy Algorithm + Sorting

We use a hash table or array $cnt$ to count the number of occurrences of each letter in the string $word$. Next, we sort the letters in descending order of their counts, and then group every $8$ letters together, assigning each group to the $8$ keys.

The time complexity is $O(n + |\Sigma| \times \log |\Sigma|)$, and the space complexity is $O(|\Sigma|)$. Here, $n$ is the length of the string $word$, and $\Sigma$ is the set of letters that appear in the string $word$.

class Solution:
  def minimumPushes(self, word: str) -> int:
    cnt = Counter(word)
    ans = 0
    for i, x in enumerate(sorted(cnt.values(), reverse=True)):
      ans += (i // 8 + 1) * x
    return ans

class Solution {
  public int minimumPushes(String word) {
    int[] cnt = new int[26];
    for (int i = 0; i < word.length(); ++i) {
      ++cnt[word.charAt(i) - 'a'];
    }
    Arrays.sort(cnt);
    int ans = 0;
    for (int i = 0; i < 26; ++i) {
      ans += (i / 8 + 1) * cnt[26 - i - 1];
    }
    return ans;
  }
}

class Solution {
public:
  int minimumPushes(string word) {
    vector<int> cnt(26);
    for (char& c : word) {
      ++cnt[c - 'a'];
    }
    sort(cnt.rbegin(), cnt.rend());
    int ans = 0;
    for (int i = 0; i < 26; ++i) {
      ans += (i / 8 + 1) * cnt[i];
    }
    return ans;
  }
};

func minimumPushes(word string) (ans int) {
  cnt := make([]int, 26)
  for _, c := range word {
    cnt[c-'a']++
  }
  sort.Ints(cnt)
  for i := 0; i < 26; i++ {
    ans += (i/8 + 1) * cnt[26-i-1]
  }
  return
}

function minimumPushes(word: string): number {
  const cnt: number[] = Array(26).fill(0);
  for (const c of word) {
    ++cnt[c.charCodeAt(0) - 'a'.charCodeAt(0)];
  }
  cnt.sort((a, b) => b - a);
  let ans = 0;
  for (let i = 0; i < 26; ++i) {
    ans += (((i / 8) | 0) + 1) * cnt[i];
  }
  return ans;
}