Split a String Into the Max Number of Unique Substrings

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

Split a String Into the Max Number of Unique Substrings

You're given a string s, and your task is to split it into the maximum possible number of unique substrings. Think of it as cutting a rope into pieces where no two pieces can be identical!

The Rules:
• You can split the string into any list of non-empty substrings
• When concatenated back together, these substrings must form the original string
• All substrings must be unique - no duplicates allowed!
• A substring is any contiguous sequence of characters

Goal: Return the maximum number of unique substrings you can create.

Example: For string "ababccc", one optimal split could be ["a", "b", "ab", "c", "cc"] giving us 5 unique substrings.

Input & Output

example_1.py — Basic Case

$ Input: s = "ababccc"

› Output: 5

💡 Note: One optimal split is ["a", "b", "ab", "c", "cc"] which gives us 5 unique substrings. We could also do ["a", "ba", "b", "c", "cc"] for the same result.

example_2.py — Simple Case

$ Input: s = "aba"

› Output: 2

💡 Note: We can split it as ["a", "ba"] or ["ab", "a"], both giving 2 unique substrings. We can't do ["a", "b", "a"] because "a" would be repeated.

example_3.py — All Same Characters

$ Input: s = "aa"

› Output: 1

💡 Note: Since both characters are the same, we cannot split it into unique substrings. The only option is ["aa"], giving us 1 unique substring.

Constraints

1 ≤ s.length ≤ 16
s contains only lowercase English letters
Small constraint allows exponential solutions

Visualization

Tap to expand

Understanding the Visualization

Start with full string

We have "ababccc" and need to find the maximum unique splits

Try first cut

We can cut "a" or "ab" or "aba" etc. as the first piece

Recursively solve remainder

For each first piece, solve the remaining string optimally

Backtrack and try alternatives

Remove pieces from our used set and try different combinations

Find maximum

Keep track of the best solution found across all attempts

Key Takeaway

🎯 Key Insight: Backtracking with a hash set allows us to efficiently explore all possible string splits while avoiding duplicate substrings. The key is to add/remove substrings from our used set as we explore different paths, ensuring we find the maximum number of unique splits possible.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 15

This problem requires backtracking with memoization. The optimal approach explores all possible ways to split the string while maintaining a set of used substrings. At each position, we try every possible substring length, and if the substring hasn't been used before, we recursively solve for the remaining string. The key insight is to backtrack by removing substrings from the used set when exploring alternative paths.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(2^n)	O(n)	Try all possible ways to split the string and find the maximum unique substrings

Brute Force Backtracking — Algorithm Steps

Start from the beginning of the string
Try every possible substring length from current position
For each substring, check if it's already been used
If not used, add it to the set and recursively solve for remaining string
Backtrack by removing the substring from the set
Keep track of the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin exploring all possible first substrings

Try substring 'a'

Add 'a' to used set, explore remaining string 'babccc'

Continue recursively

For each position, try all possible substring lengths

Backtrack when needed

Remove substring from used set when backtracking

Code -

solution.c — C

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

#define MAX_LEN 100
#define MAX_SUBSTRINGS 50

char used[MAX_SUBSTRINGS][MAX_LEN];
int usedCount = 0;

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);
}

void removeUsed() {
    usedCount--;
}

int backtrack(char* s, int start, int len) {
    if (start == len) {
        return 0;
    }
    
    int maxCount = 0;
    char substring[MAX_LEN];
    
    // Try all possible substring lengths from current position
    for (int end = start + 1; end <= len; end++) {
        strncpy(substring, s + start, end - start);
        substring[end - start] = '\0';
        
        if (!isUsed(substring)) {
            addUsed(substring);
            int count = 1 + backtrack(s, end, len);
            if (count > maxCount) {
                maxCount = count;
            }
            removeUsed();  // backtrack
        }
    }
    
    return maxCount;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we try every possible way to split string of length n, which is 2^(n-1) ways

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and set to store used substrings

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 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 Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler