Unique Letter String LT828

A character is unique in string S if it occurs exactly once in it.

For example, in string S = "LETTER", the only unique characters are "L" and "R".

Let's define UNIQ(S) as the number of unique characters in string S.

For example, UNIQ("LETTER") =  2.

Given a string S with only uppercases, calculate the sum of UNIQ(substring) over all non-empty substrings of S.

If there are two or more equal substrings at different positions in S, we consider them different.

Since the answer can be very large, return the answer modulo 10 ^ 9 + 7.

Idea 1. Dynamic programming, it's a bit tricky, need to store last two indexes for each char appears in the array, assume dp[i] is the number of unique characters ending at s[i]

dp[i] = dp[i-1] + (i - last[s[i]]) - (last[s[i]] - 2ndLast[s[i]]))

ABCBDAB

i = 0, {A}, dp[0] = 1

i = 1, {AB, B}, dp[1] = 3

i = 2, {ABC, BC, C}, dp[2] = 6

i = 3, {ABCB, BCB, CB, B}, dp[3] = 6 = dp[2] + (3 - 1) -(1 - (-1)) = 6

Time complexity: O(n)

Space complexity: O(n) or O(26)

 class Solution {
     public int uniqueLetterString(String S) {
         int[] last = new int[26];
         int[] secondLast = new int[26];
         Arrays.fill(last, -1);
         Arrays.fill(secondLast, -1);

         int dp = 0;
         int result = 0;
         for(int i = 0; i < S.length(); ++i) {
             int a = S.charAt(i) - 'A';
             dp = dp + (i -last[a]) - (last[a] - secondLast[a]);
             result += dp;
             secondLast[a] = last[a];
             last[a] = i;
         }

         return result;
     }
 }

Idea 2. Similar to Sum of Subsequence Widths LT891, instead of getting all the unique characters for substring ending at index i, focus on the contribution of each character, count how many times it appears as a unique character in a substring, then sum it up for each char in the string and get the result.

ABCBDAB, for the middle 'B', on the left, substring ending at 'B': B, CB

　　　　　　　　　　　　　　on the right, substring starting at 'B': B, BD, BDA

'B' can appears 2 * 3 = 6 substring, B, BD, BDA, CB, CBD, CBDA,

It can observed that the count is depend on the nearest same char on the left and on the right,

　　(i - prev) * (next - i)

Time complexity: O(n)

Space complexity: O(n)

Using hashmap to store the index of char in the string

 class Solution {
     public int uniqueLetterString(String S) {
         Map<Character, List<Integer>> charIndex = new HashMap<>();
         int n = S.length();
         for(int i = 0; i < n; ++i) {
             char c = S.charAt(i);
             if(!charIndex.containsKey(c)) {
                 charIndex.put(c, new ArrayList<Integer>());
             }
             charIndex.get(c).add(i);
         }

         long result = 0;
         long mod = (long)1e9+7;

         for(List<Integer> positions: charIndex.values()) {

             for(int i = 0; i < positions.size(); ++i) {
                 int prev = i > 0? positions.get(i-1) : -1;
                 int next = i < positions.size()-1? positions.get(i+1) : n;

                 int curr = positions.get(i);
                 result = (result + (curr-prev) * (next - curr))%mod;
             }
         }

         return (int)result;
     }
 }

Idea 2.b store index at array prev[], next[] by scanning the string from left to right, and right to left

Time complexity: O(n)

Space complexity: O(n)

 class Solution {
     public int uniqueLetterString(String S) {
         int n = S.length();
         int[] charIndex = new int[26];
         Arrays.fill(charIndex, -1);

         int[] prev = new int[n];
         for(int i = 0; i < n; ++i) {
             int a = S.charAt(i) - 'A';
             prev[i] = charIndex[a];
             charIndex[a] = i;
         }

         Arrays.fill(charIndex, n);
         int[] next = new int[n];
         for(int i = n-1; i >= 0;--i) {
             int a = S.charAt(i) - 'A';
             next[i] = charIndex[a];
             charIndex[a] = i;
         }

         int result = 0;
         int mod = (int)(1e9) + 7;

         for(int i = 0; i < n; ++i) {
             result = (result + (i - prev[i])*(next[i] - i))%mod;
         }

         return result;
     }
 }

Example 1:

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

Example 2:

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