Number of Distinct Substrings in a String

Number of Distinct Substrings in a String - Problem

Given a string s, return the number of distinct substrings of s.

A substring of a string is obtained by deleting any number of characters (possibly zero) from the front of the string and any number (possibly zero) from the back of the string.

For example, if s = "abc", the substrings are: "a", "b", "c", "ab", "bc", "abc", and the empty string "". However, since we only count distinct substrings, duplicates are counted only once.

Input & Output

Example 1 — Simple String

$ Input: s = "abc"

› Output: 6

💡 Note: The distinct substrings are: "a", "b", "c", "ab", "bc", "abc". Total count is 6.

Example 2 — Repeated Characters

$ Input: s = "aaa"

› Output: 3

💡 Note: The distinct substrings are: "a", "aa", "aaa". Even though there are multiple 'a' characters, we only count unique substrings.

Example 3 — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: Only one substring possible: "a". Count is 1.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to generate all possible substrings and use a hash set to automatically handle uniqueness. The brute force approach with set storage works well for the given constraints. Best approach is brute force with set for simplicity. Time: O(n³), Space: O(n³)

Common Approaches

✓ Brute Force with Set

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

Use nested loops to generate every possible substring of the input string. Store each substring in a hash set which automatically handles duplicates. The final count is the size of the set.

Rolling Hash Optimization

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

Instead of creating actual substring objects, compute polynomial rolling hashes for each substring. This reduces memory usage and improves performance by avoiding string operations. Store only the hashes in a set.

Brute Force with Set — Algorithm Steps

Iterate through all starting positions
For each start, iterate through all ending positions
Extract substring and add to set
Return set size

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all substrings using nested loops

Store

Add each substring to set (duplicates ignored)

Count

Return size of set

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_SUBSTRINGS 500000

int solution(char* s) {
    static char substrings[MAX_SUBSTRINGS][MAX_LEN];
    int count = 0;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            char temp[MAX_LEN];
            int len = j - i + 1;
            strncpy(temp, s + i, len);
            temp[len] = '\0';
            
            // Check if substring already exists
            int exists = 0;
            for (int k = 0; k < count; k++) {
                if (strcmp(substrings[k], temp) == 0) {
                    exists = 1;
                    break;
                }
            }
            
            if (!exists) {
                strcpy(substrings[count], temp);
                count++;
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops O(n²) to generate positions, substring extraction O(n)

⚠ Quadratic Growth

Space Complexity

O(n³)

Set stores up to O(n²) substrings, each of average length O(n)

⚠ Quadratic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler