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 is a contiguous sequence of characters within a string. For example, "abc" is a substring of "abcdef". Note that we need to count all possible substrings, including the empty string and the string itself, but each unique substring should only be counted once.

Example: For string "aba", the substrings are: "", "a", "b", "ab", "ba", "aba". Note that "a" appears twice but is only counted once.

Input & Output

example_1.py — Basic Case

$ Input: s = "aba"

› Output: 6

💡 Note: The distinct substrings are: "", "a", "b", "ab", "ba", "aba". Note that "a" appears at positions 0 and 2, but is only counted once.

example_2.py — All Same Characters

$ Input: s = "aaa"

› Output: 4

💡 Note: The distinct substrings are: "", "a", "aa", "aaa". Even though there are many overlapping substrings, we only count unique ones.

example_3.py — Single Character

$ Input: s = "a"

› Output: 2

💡 Note: The distinct substrings are: "" (empty string) and "a". Total count is 2.

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize our 'index book' (hash set) and start with the empty entry

Generate

For each starting position, create all possible phrases (substrings) extending from that position

Check Duplicates

Before adding each phrase to our index, check if it already exists

Count Results

The final count in our index represents all unique substrings

Key Takeaway

🎯 Key Insight: Using a hash set automatically handles duplicate detection, making the algorithm simple yet efficient. The time complexity is dominated by the O(n²) substring generation, while space complexity depends on the number of unique substrings.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) for nested loops, but each hash computation is O(1) with rolling hash

⚠ Quadratic Growth

Space Complexity

O(n²)

Store O(n²) hash values in the set, each taking O(1) space

⚠ Quadratic Space

Constraints

0 ≤ s.length ≤ 1000
s consists of lowercase English letters only
Time limit: 2 seconds per test case

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses a hash set to store unique substrings. The brute force method generates all O(n²) substrings in O(n³) time, while the optimized rolling hash approach achieves O(n²) time complexity by avoiding substring creation and using incremental hash computation.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Hash Set (Rolling Hash)	O(n²)	O(n²)	Use rolling hash technique to generate substrings more efficiently
Brute Force (Generate All Substrings)	O(n³)	O(n³)	Generate all possible substrings and store in a set to ensure uniqueness

Optimized Hash Set (Rolling Hash) — Algorithm Steps

Initialize a hash set to store hash values of unique substrings
For each starting position, use rolling hash to compute hash values
Incrementally build hash values for substrings starting at that position
Add each hash value to the set
Return the size of the set plus 1 (for empty string)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at each starting position

Rolling Hash

Incrementally compute hash values

Store Hash

Add hash to set instead of substring

Continue

Extend to next character using rolling hash

Code -

solution.c — C

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

#define MAX_LEN 1000
#define HASH_SIZE 100000

struct HashNode {
    long long hash;
    struct HashNode* next;
};

struct HashTable {
    struct HashNode* table[HASH_SIZE];
};

void insertHash(struct HashTable* ht, long long hash) {
    int index = abs(hash) % HASH_SIZE;
    struct HashNode* node = ht->table[index];
    
    while (node) {
        if (node->hash == hash) return; // Already exists
        node = node->next;
    }
    
    // Insert new node
    struct HashNode* newNode = malloc(sizeof(struct HashNode));
    newNode->hash = hash;
    newNode->next = ht->table[index];
    ht->table[index] = newNode;
}

int countUniqueHashes(struct HashTable* ht) {
    int count = 0;
    for (int i = 0; i < HASH_SIZE; i++) {
        struct HashNode* node = ht->table[i];
        while (node) {
            count++;
            node = node->next;
        }
    }
    return count;
}

int countDistinctSubstrings(char* s) {
    int len = strlen(s);
    if (len == 0) return 1;
    
    struct HashTable ht = {0};
    long long base = 31;
    long long mod = 1000000007LL;
    
    // Add empty string (hash = 0)
    insertHash(&ht, 0);
    
    // Rolling hash for all substrings
    for (int i = 0; i < len; i++) {
        long long hashVal = 0;
        for (int j = i; j < len; j++) {
            hashVal = (hashVal * base + s[j]) % mod;
            insertHash(&ht, hashVal);
        }
    }
    
    return countUniqueHashes(&ht);
}

int main() {
    char s[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
    }
    if (s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = '\0';
    }
    
    printf("%d\n", countDistinctSubstrings(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) for nested loops, but each hash computation is O(1) with rolling hash

⚠ Quadratic Growth

Space Complexity

O(n²)

Store O(n²) hash values in the set, each taking O(1) space

⚠ Quadratic Space

Constraints

0 ≤ s.length ≤ 1000
s consists of lowercase English letters only
Time limit: 2 seconds per test case

28.4K Views

Medium Frequency

~12 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Hash Set (Rolling Hash) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler