Maximum Number of Non-Overlapping Substrings

Maximum Number of Non-Overlapping Substrings - Problem

String Greedy Hard

Given a string s of lowercase letters, you need to find the maximum number of non-empty substrings of s that meet the following conditions:

The substrings do not overlap, that is for any two substrings s[i..j] and s[x..y], either j < x or i > y is true.
A substring that contains a certain character c must also contain all occurrences of c.

Find the maximum number of substrings that meet the above conditions. If there are multiple solutions with the same number of substrings, return the one with minimum total length. It can be shown that there exists a unique solution of minimum total length.

Notice that you can return the substrings in any order.

Input & Output

Example 1 — Basic Case

$ Input: s = "aabcc"

› Output: ["aa", "b", "cc"]

💡 Note: Character 'a' appears at indices 0,1 so any substring with 'a' must include both. Similarly 'c' at indices 3,4. The substring "b" at index 2 is valid alone. All three substrings are non-overlapping.

Example 2 — Single Character

$ Input: s = "aba"

› Output: ["aba"]

💡 Note: Character 'a' appears at indices 0,2 so any substring containing 'a' must span the entire string. The optimal solution is the whole string.

Example 3 — All Different

$ Input: s = "abcd"

› Output: ["a", "b", "c", "d"]

💡 Note: Each character appears exactly once, so each character forms its own valid substring. Maximum count is 4.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Input Analysis

String "aabcc" with character positions

Valid Substrings

Find substrings containing all occurrences of their characters

Non-Overlapping Selection

Choose maximum number without overlap

Key Takeaway

🎯 Key Insight: If a substring contains a character, it must contain ALL occurrences of that character to be valid

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is that if a substring contains a character, it must contain ALL occurrences of that character. Best approach is greedy selection of shortest valid intervals. Time: O(n²), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Combinations	O(2ⁿ)	O(n²)	Generate all possible valid substrings and try all combinations
Greedy - Select Shortest Valid Intervals	O(n²)	O(n)	Find minimal valid substrings and greedily select shortest non-overlapping ones

Brute Force - Check All Combinations — Algorithm Steps

Step 1: Find first and last occurrence of each character
Step 2: Generate all valid substrings that contain all occurrences of their characters
Step 3: Use backtracking to try all combinations of non-overlapping substrings
Step 4: Return the combination with maximum count and minimum total length

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Character Bounds

Locate first and last occurrence of each character

Generate Valid Substrings

Check each substring contains all occurrences of its characters

Try Combinations

Use backtracking to find maximum non-overlapping substrings

Code -

solution.c — C

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

typedef struct {
    int start, end;
    char substring[1001];
} Interval;

int maxCount = 0;
int minLength = 10000;
char result[100][1001];
int resultSize = 0;

bool isValidSubstring(char* s, int start, int end, int first[], int last[]) {
    bool seen[26] = {false};
    for (int i = start; i <= end; i++) {
        seen[s[i] - 'a'] = true;
    }
    
    for (int i = 0; i < 26; i++) {
        if (seen[i] && (first[i] < start || last[i] > end)) {
            return false;
        }
    }
    return true;
}

bool hasOverlap(Interval* intervals, int size, int start, int end) {
    for (int i = 0; i < size; i++) {
        if (!(end < intervals[i].start || start > intervals[i].end)) {
            return true;
        }
    }
    return false;
}

void backtrack(Interval* validSubstrings, int validCount, int index, Interval* current, int currentSize, int length) {
    if (index == validCount) {
        if (currentSize > maxCount || (currentSize == maxCount && length < minLength)) {
            maxCount = currentSize;
            minLength = length;
            resultSize = currentSize;
            for (int i = 0; i < currentSize; i++) {
                strcpy(result[i], current[i].substring);
            }
        }
        return;
    }
    
    Interval curr = validSubstrings[index];
    
    if (!hasOverlap(current, currentSize, curr.start, curr.end)) {
        current[currentSize] = curr;
        backtrack(validSubstrings, validCount, index + 1, current, currentSize + 1, length + strlen(curr.substring));
    }
    
    backtrack(validSubstrings, validCount, index + 1, current, currentSize, length);
}

int solution(char* s) {
    int n = strlen(s);
    int first[26], last[26];
    
    for (int i = 0; i < 26; i++) {
        first[i] = -1;
        last[i] = -1;
    }
    
    for (int i = 0; i < n; i++) {
        int c = s[i] - 'a';
        if (first[c] == -1) first[c] = i;
        last[c] = i;
    }
    
    Interval validSubstrings[10000];
    int validCount = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            if (isValidSubstring(s, i, j, first, last)) {
                validSubstrings[validCount].start = i;
                validSubstrings[validCount].end = j;
                strncpy(validSubstrings[validCount].substring, s + i, j - i + 1);
                validSubstrings[validCount].substring[j - i + 1] = '\0';
                validCount++;
            }
        }
    }
    
    maxCount = 0;
    minLength = 10000;
    resultSize = 0;
    
    Interval current[100];
    backtrack(validSubstrings, validCount, 0, current, 0, 0);
    
    return resultSize;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int count = solution(s);
    for (int i = 0; i < count; i++) {
        printf("%s\n", result[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Exponential combinations of valid substrings to check

✓ Linear Growth

Space Complexity

O(n²)

Storing all valid substrings and recursion stack

⚠ Quadratic Space

15.0K Views

Medium Frequency

~25 min Avg. Time

425 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 - Check All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler