Welcome to Subscribe On Youtube

1647. Minimum Deletions to Make Character Frequencies Unique

Description

A string s is called good if there are no two different characters in s that have the same frequency.

Given a string s, return the minimum number of characters you need to delete to make s good.

The frequency of a character in a string is the number of times it appears in the string. For example, in the string "aab", the frequency of 'a' is 2, while the frequency of 'b' is 1.

 

Example 1:

Input: s = "aab"
Output: 0
Explanation: s is already good.

Example 2:

Input: s = "aaabbbcc"
Output: 2
Explanation: You can delete two 'b's resulting in the good string "aaabcc".
Another way it to delete one 'b' and one 'c' resulting in the good string "aaabbc".

Example 3:

Input: s = "ceabaacb"
Output: 2
Explanation: You can delete both 'c's resulting in the good string "eabaab".
Note that we only care about characters that are still in the string at the end (i.e. frequency of 0 is ignored).

 

Constraints:

• 1 <= s.length <= 105
• s contains only lowercase English letters.

Solutions

Solution 1: Array + Sorting

First, we use an array $\textit{cnt}$ of length $26$ to count the occurrences of each letter in the string $s$.

Then, we sort the array $\textit{cnt}$ in descending order. We define a variable $\textit{pre}$ to record the current number of occurrences of the letter.

Next, we traverse each element $v$ in the array $\textit{cnt}$. If the current $\textit{pre}$ is $0$, we directly add $v$ to the answer. Otherwise, if $v \geq \textit{pre}$, we add $v - \textit{pre} + 1$ to the answer and decrement $\textit{pre}$ by $1$. Otherwise, we directly update $\textit{pre}$ to $v$. Then, we continue to the next element.

After traversing, we return the answer.

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 $s$, and $

\Sigma

$ is the size of the alphabet. In this problem, $

\Sigma

= 26$.

Solution 2

This implementation uses sorting, followed by hash table. It traverses the relevant values and updates its state as each value is processed. A keyed container records values that must be found or updated efficiently. Ordering the data first makes the subsequent comparisons deterministic.

• Java
• C++
• Python
• Go
• TypeScript
• Rust

• class Solution {
      public int minDeletions(String s) {
          int[] cnt = new int[26];
          for (int i = 0; i < s.length(); ++i) {
              ++cnt[s.charAt(i) - 'a'];
          }
          Arrays.sort(cnt);
          int ans = 0;
          for (int i = 24; i >= 0; --i) {
              while (cnt[i] >= cnt[i + 1] && cnt[i] > 0) {
                  --cnt[i];
                  ++ans;
              }
          }
          return ans;
      }
  }
  
  
  // Solution 2
  class Solution {
      public int minDeletions(String s) {
          int[] cnt = new int[26];
          for (int i = 0; i < s.length(); ++i) {
              ++cnt[s.charAt(i) - 'a'];
          }
          Arrays.sort(cnt);
          int ans = 0, pre = 1 << 30;
          for (int i = 25; i >= 0; --i) {
              int v = cnt[i];
              if (pre == 0) {
                  ans += v;
              } else if (v >= pre) {
                  ans += v - pre + 1;
                  --pre;
              } else {
                  pre = v;
              }
          }
          return ans;
      }
  }
  
  

• class Solution {
  public:
      int minDeletions(string s) {
          vector<int> cnt(26);
          for (char& c : s) ++cnt[c - 'a'];
          sort(cnt.rbegin(), cnt.rend());
          int ans = 0;
          for (int i = 1; i < 26; ++i) {
              while (cnt[i] >= cnt[i - 1] && cnt[i] > 0) {
                  --cnt[i];
                  ++ans;
              }
          }
          return ans;
      }
  };
  
  
  // Solution 2
  class Solution {
  public:
      int minDeletions(string s) {
          vector<int> cnt(26);
          for (char& c : s) ++cnt[c - 'a'];
          sort(cnt.rbegin(), cnt.rend());
          int ans = 0, pre = 1 << 30;
          for (int& v : cnt) {
              if (pre == 0) {
                  ans += v;
              } else if (v >= pre) {
                  ans += v - pre + 1;
                  --pre;
              } else {
                  pre = v;
              }
          }
          return ans;
      }
  };
  
  

• class Solution:
      def minDeletions(self, s: str) -> int:
          cnt = Counter(s)
          ans, pre = 0, inf
          for v in sorted(cnt.values(), reverse=True):
              if pre == 0:
                  ans += v
              elif v >= pre:
                  ans += v - pre + 1
                  pre -= 1
              else:
                  pre = v
          return ans
  
  
  # Solution 2
  class Solution:
      def minDeletions(self, s: str) -> int:
          cnt = Counter(s)
          vals = sorted(cnt.values(), reverse=True)
          ans = 0
          for i in range(1, len(vals)):
              while vals[i] >= vals[i - 1] and vals[i] > 0:
                  vals[i] -= 1
                  ans += 1
          return ans
  
  

• func minDeletions(s string) (ans int) {
  	cnt := make([]int, 26)
  	for _, c := range s {
  		cnt[c-'a']++
  	}
  	sort.Sort(sort.Reverse(sort.IntSlice(cnt)))
  	for i := 1; i < 26; i++ {
  		for cnt[i] >= cnt[i-1] && cnt[i] > 0 {
  			cnt[i]--
  			ans++
  		}
  	}
  	return
  }
  
  
  // Solution 2
  func minDeletions(s string) (ans int) {
  	cnt := make([]int, 26)
  	for _, c := range s {
  		cnt[c-'a']++
  	}
  	sort.Sort(sort.Reverse(sort.IntSlice(cnt)))
  	pre := 1 << 30
  	for _, v := range cnt {
  		if pre == 0 {
  			ans += v
  		} else if v >= pre {
  			ans += v - pre + 1
  			pre--
  		} else {
  			pre = v
  		}
  	}
  	return
  }
  
  

• function minDeletions(s: string): number {
      let map = {};
      for (let c of s) {
          map[c] = (map[c] || 0) + 1;
      }
      let ans = 0;
      let vals: number[] = Object.values(map);
      vals.sort((a, b) => a - b);
      for (let i = 1; i < vals.length; ++i) {
          while (vals[i] > 0 && i != vals.indexOf(vals[i])) {
              --vals[i];
              ++ans;
          }
      }
      return ans;
  }
  
  

• impl Solution {
      #[allow(dead_code)]
      pub fn min_deletions(s: String) -> i32 {
          let mut cnt = vec![0; 26];
          let mut ans = 0;
  
          for c in s.chars() {
              cnt[((c as u8) - ('a' as u8)) as usize] += 1;
          }
  
          cnt.sort_by(|&lhs, &rhs| { rhs.cmp(&lhs) });
  
          for i in 1..26 {
              while cnt[i] >= cnt[i - 1] && cnt[i] > 0 {
                  cnt[i] -= 1;
                  ans += 1;
              }
          }
  
          ans
      }
  }
  
  

All Problems

All Solutions