Split a String Into the Max Number of Unique Substrings

Split a String Into the Max Number of Unique Substrings - Problem

Given a string s, return the maximum number of unique substrings that the given string can be split into.

You can split string s into any list of non-empty substrings, where the concatenation of the substrings forms the original string. However, you must split the substrings such that all of them are unique.

A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Basic Case

$ Input: s = "ababccc"

› Output: 5

💡 Note: One optimal split: ["a", "b", "ab", "c", "cc"] - all 5 substrings are unique

Example 2 — Short String

$ Input: s = "aba"

› Output: 2

💡 Note: Best split: ["ab", "a"] - 2 unique substrings (better than ["a", "ba"] which also gives 2)

Example 3 — All Same Characters

$ Input: s = "aa"

› Output: 1

💡 Note: Only one way: ["aa"] - cannot split into ["a", "a"] as both substrings would be identical

Constraints

1 ≤ s.length ≤ 16
s contains only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Input

String s = "ababccc" to be split

Process

Find all ways to split into unique substrings

Output

Maximum number of unique substrings = 5

Key Takeaway

🎯 Key Insight: Use backtracking to explore all splitting possibilities while maintaining a set of used substrings

Asked in

G Google 15 a Amazon 12

The key insight is to use backtracking to systematically explore all possible ways to split the string while tracking used substrings in a hash set. The optimal approach uses backtracking with pruning to avoid exploring paths that cannot improve the current maximum. Time: O(2^n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Pruning	O(2^n)	O(n)	Systematically explore splits with early termination
Brute Force Recursion	O(2^n)	O(n)	Try all possible ways to split the string without optimization

Backtracking with Pruning — Algorithm Steps

Try each possible first substring
Recursively solve remaining string
Backtrack and try next possibility
Prune paths that cannot improve current maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Path

Explore one splitting path systematically

Prune

Skip paths that cannot beat current maximum

Backtrack

Return to previous state and try next possibility

Code -

solution.c — C

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

#define MAX_LEN 17
#define MAX_SUBSTRINGS 100

char used[MAX_SUBSTRINGS][MAX_LEN];
int usedCount;
int maxResult;

int isUsed(char* substring) {
    for (int i = 0; i < usedCount; i++) {
        if (strcmp(used[i], substring) == 0) {
            return 1;
        }
    }
    return 0;
}

void addUsed(char* substring) {
    strcpy(used[usedCount], substring);
    usedCount++;
}

void removeUsed() {
    usedCount--;
}

void backtrack(char* s, int start, int len, int currentCount) {
    // Pruning: if remaining characters + current count <= max, skip
    if (currentCount + (len - start) <= maxResult) {
        return;
    }
    
    if (start == len) {
        if (currentCount > maxResult) {
            maxResult = currentCount;
        }
        return;
    }
    
    char substring[MAX_LEN];
    
    for (int end = start + 1; end <= len; end++) {
        strncpy(substring, s + start, end - start);
        substring[end - start] = '\0';
        
        if (!isUsed(substring)) {
            addUsed(substring);
            backtrack(s, end, len, currentCount + 1);
            removeUsed();
        }
    }
}

int solution(char* s) {
    usedCount = 0;
    maxResult = 0;
    backtrack(s, 0, strlen(s), 0);
    return maxResult;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Still explores exponential possibilities but with pruning to reduce actual work

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth n and hash set for tracking used substrings

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler