Welcome to Subscribe On Youtube

828. Count Unique Characters of All Substrings of a Given String

Description

Let's define a function countUniqueChars(s) that returns the number of unique characters in s.

• For example, calling countUniqueChars(s) if s = "LEETCODE" then "L", "T", "C", "O", "D" are the unique characters since they appear only once in s, therefore countUniqueChars(s) = 5.

Given a string s, return the sum of countUniqueChars(t) where t is a substring of s. The test cases are generated such that the answer fits in a 32-bit integer.

Notice that some substrings can be repeated so in this case you have to count the repeated ones too.

 

Example 1:

Input: s = "ABC"
Output: 10
Explanation: All possible substrings are: "A","B","C","AB","BC" and "ABC".
Every substring is composed with only unique letters.
Sum of lengths of all substring is 1 + 1 + 1 + 2 + 2 + 3 = 10

Example 2:

Input: s = "ABA"
Output: 8
Explanation: The same as example 1, except countUniqueChars("ABA") = 1.

Example 3:

Input: s = "LEETCODE"
Output: 92

 

Constraints:

• 1 <= s.length <= 105
• s consists of uppercase English letters only.

Solutions

Solution 1: Calculate the Contribution of Each Character

For each character $c_i$ in the string $s$, when it appears only once in a substring, it contributes to the count of unique characters in that substring.

Therefore, we only need to calculate for each character $c_i$, how many substrings contain this character only once.

We use a hash table or an array $d$ of length $26$, to store the positions of each character in $s$ in order of index.

For each character $c_i$, we iterate through each position $p$ in $d[c_i]$, find the adjacent positions $l$ on the left and $r$ on the right, then the number of substrings that meet the requirements by expanding from position $p$ to both sides is $(p - l) \times (r - p)$. We perform this operation for each character, add up the contributions of all characters, and get the answer.

The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the string $s$.

• Java
• C++
• Python
• Go
• TypeScript
• RenderScript

• class Solution {
      public int uniqueLetterString(String s) {
          List<Integer>[] d = new List[26];
          Arrays.setAll(d, k -> new ArrayList<>());
          for (int i = 0; i < 26; ++i) {
              d[i].add(-1);
          }
          for (int i = 0; i < s.length(); ++i) {
              d[s.charAt(i) - 'A'].add(i);
          }
          int ans = 0;
          for (var v : d) {
              v.add(s.length());
              for (int i = 1; i < v.size() - 1; ++i) {
                  ans += (v.get(i) - v.get(i - 1)) * (v.get(i + 1) - v.get(i));
              }
          }
          return ans;
      }
  }
  

• class Solution {
  public:
      int uniqueLetterString(string s) {
          vector<vector<int>> d(26, {-1});
          for (int i = 0; i < s.size(); ++i) {
              d[s[i] - 'A'].push_back(i);
          }
          int ans = 0;
          for (auto& v : d) {
              v.push_back(s.size());
              for (int i = 1; i < v.size() - 1; ++i) {
                  ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
              }
          }
          return ans;
      }
  };
  

• class Solution:
      def uniqueLetterString(self, s: str) -> int:
          d = defaultdict(list)
          for i, c in enumerate(s):
              d[c].append(i)
          ans = 0
          for v in d.values():
              v = [-1] + v + [len(s)]
              for i in range(1, len(v) - 1):
                  ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i])
          return ans
  
  

• func uniqueLetterString(s string) (ans int) {
  	d := make([][]int, 26)
  	for i := range d {
  		d[i] = []int{-1}
  	}
  	for i, c := range s {
  		d[c-'A'] = append(d[c-'A'], i)
  	}
  	for _, v := range d {
  		v = append(v, len(s))
  		for i := 1; i < len(v)-1; i++ {
  			ans += (v[i] - v[i-1]) * (v[i+1] - v[i])
  		}
  	}
  	return
  }
  

• function uniqueLetterString(s: string): number {
      const d: number[][] = Array.from({ length: 26 }, () => [-1]);
      for (let i = 0; i < s.length; ++i) {
          d[s.charCodeAt(i) - 'A'.charCodeAt(0)].push(i);
      }
      let ans = 0;
      for (const v of d) {
          v.push(s.length);
  
          for (let i = 1; i < v.length - 1; ++i) {
              ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
          }
      }
      return ans;
  }
  
  

• impl Solution {
      pub fn unique_letter_string(s: String) -> i32 {
          let mut d: Vec<Vec<i32>> = vec![vec![-1; 1]; 26];
          for (i, c) in s.chars().enumerate() {
              d[(c as usize) - ('A' as usize)].push(i as i32);
          }
          let mut ans = 0;
          for v in d.iter_mut() {
              v.push(s.len() as i32);
              for i in 1..v.len() - 1 {
                  ans += (v[i] - v[i - 1]) * (v[i + 1] - v[i]);
              }
          }
          ans as i32
      }
  }
  
  

All Problems

All Solutions