Count Unique Characters of All Substrings of a Given String - Problem

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.

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

Input & Output

Example 1 — Basic Case

$ Input: s = "ABC"

› Output: 10

💡 Note: Substrings: "A"(1), "B"(1), "C"(1), "AB"(2), "BC"(2), "ABC"(3). Sum: 1+1+1+2+2+3 = 10

Example 2 — Repeated Characters

$ Input: s = "ABA"

› Output: 8

💡 Note: Substrings: "A"(1), "B"(1), "A"(1), "AB"(2), "BA"(2), "ABA"(1). Sum: 1+1+1+2+2+1 = 8

Example 3 — Single Character

$ Input: s = "A"

› Output: 1

💡 Note: Only one substring "A" with 1 unique character. Sum: 1

Constraints

1 ≤ s.length ≤ 10⁴
s consists of uppercase English letters only.

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 12

The key insight is to calculate each character's contribution across all substrings rather than examining each substring individually. Best approach uses contribution-based calculation in O(n) time by finding boundaries where each character remains unique. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

For each possible substring, count the frequency of characters and add up those with frequency 1. This approach examines every substring explicitly.

Contribution-Based Approach

⏱️ Time: O(n) Space: O(1)

Instead of checking every substring, calculate how many substrings each character contributes to as a unique character. For each character at position i, find the nearest same characters to the left and right to determine the range of substrings where it's unique.

Brute Force - Check All Substrings — Algorithm Steps

Generate all possible substrings
For each substring, count character frequencies
Count characters with frequency 1
Sum up all unique character counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings from the input

Count Frequencies

For each substring, count how often each character appears

Sum Unique Characters

Add up characters that appear exactly once in each substring

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int solution(char* s) {
    int total = 0;
    int n = strlen(s);
    
    // Generate all substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            // Count character frequencies for substring s[i..j-1]
            int freq[26] = {0}; // Assuming lowercase letters
            
            for (int k = i; k < j; k++) {
                freq[s[k] - 'A']++; // Adjust for uppercase if needed
            }
            
            // Count unique characters (frequency = 1)
            int uniqueCount = 0;
            for (int k = 0; k < 26; k++) {
                if (freq[k] == 1) uniqueCount++;
            }
            total += uniqueCount;
        }
    }
    
    return total;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to count frequencies for each substring

✓ Linear Growth

Space Complexity

O(1)

Only using a frequency map with at most 26 characters (constant space)

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Count Unique Characters of All Substrings of a Given String - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler