Maximum Number of Non-Overlapping Substrings

Maximum Number of Non-Overlapping Substrings - Problem

String Greedy Hard

You're given a string s containing only lowercase letters. Your task is to find the maximum number of non-overlapping substrings that satisfy two crucial conditions:

Non-overlapping: The substrings cannot share any characters (no overlap)
Character completeness: If a substring contains a character c, it must contain all occurrences of c in the original string

Your goal is to maximize the number of such substrings. If multiple solutions exist with the same count, choose the one with minimum total length.

Example: For string "adefaddaccc", you could pick substrings like "adefadda" (contains all 'a's and 'd's) and "ccc" (contains all 'c's), giving you 2 non-overlapping valid substrings.

Input & Output

example_1.py — Basic Case

$ Input: s = "adefaddaccc"

› Output: ["adefadda", "ccc"]

💡 Note: The character 'a' appears at indices 0, 4, 7, so any substring containing 'a' must span at least from 0 to 7. Similarly, 'd' appears at 1, 5, 6, 'e' at 2, 'f' at 3, and 'c' at 8, 9, 10. The optimal solution picks "adefadda" (contains all a's, d's, e's, f's) and "ccc" (contains all c's), giving us 2 non-overlapping substrings.

example_2.py — Single Character Groups

$ Input: s = "abbaccd"

› Output: ["abba", "cc", "d"]

💡 Note: Character 'a' appears at indices 0, 3, so we need positions 0-3 giving "abba". Character 'c' appears at 4, 5 giving "cc". Character 'd' appears only at 6 giving "d". This gives us 3 non-overlapping valid substrings, which is optimal.

example_3.py — All Same Character

$ Input: s = "aaaa"

› Output: ["aaaa"]

💡 Note: Since all characters are the same ('a'), any valid substring must contain all occurrences of 'a'. Therefore, the entire string "aaaa" is the only possible valid substring, giving us 1 substring.

Constraints

1 ≤ s.length ≤ 10⁵
s contains only lowercase English letters
The string is guaranteed to have at least one valid substring

Visualization

Tap to expand

Understanding the Visualization

Survey the Street

Map where each family's houses (character occurrences) are located

Claim Territories

Starting from the left, claim the smallest territory that includes complete families

Maximize Count

Greedily select shortest territories to maximize the total number of territories

Key Takeaway

🎯 Key Insight: Use greedy approach - always claim the shortest territory that satisfies all family requirements, maximizing the total number of territories.

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses a greedy approach with character boundary tracking. First, map each character's first and last positions. Then, for each starting position, find the shortest valid substring by expanding boundaries to include all occurrences of encountered characters. This O(n) time algorithm maximizes the number of substrings while minimizing total length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n^2)	O(n)	Generate all possible substring combinations and check validity
Greedy with Character Mapping (Optimal)	O(n)	O(1)	Find valid substrings greedily by tracking character boundaries

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible ways to partition the string into substrings
For each partition, check if substrings are non-overlapping
For each substring, verify it contains all occurrences of its characters
Track the best solution (max count, min length)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Create all possible ways to split the string

Validate Each Partition

Check if each substring contains complete character sets

Track Best Solution

Keep the solution with maximum count and minimum length

Code -

solution.c — C

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

#define MAX_LEN 1000

typedef struct {
    char** strings;
    int count;
    int capacity;
} StringArray;

StringArray* createStringArray() {
    StringArray* arr = malloc(sizeof(StringArray));
    arr->capacity = 10;
    arr->strings = malloc(sizeof(char*) * arr->capacity);
    arr->count = 0;
    return arr;
}

void addString(StringArray* arr, const char* str) {
    if (arr->count >= arr->capacity) {
        arr->capacity *= 2;
        arr->strings = realloc(arr->strings, sizeof(char*) * arr->capacity);
    }
    arr->strings[arr->count] = malloc(strlen(str) + 1);
    strcpy(arr->strings[arr->count], str);
    arr->count++;
}

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

StringArray* maxNumOfSubstrings(const 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 idx = s[i] - 'a';
        if (first[idx] == -1) {
            first[idx] = i;
        }
        last[idx] = i;
    }
    
    StringArray* result = createStringArray();
    
    // Simple greedy approach for brute force simulation
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            if (isValidSubstring(s, i, j, first, last)) {
                char* substring = malloc(j - i + 2);
                strncpy(substring, s + i, j - i + 1);
                substring[j - i + 1] = '\0';
                addString(result, substring);
                free(substring);
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char s[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    char* start = strchr(s, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        strcpy(s, start);
    }
    
    StringArray* result = maxNumOfSubstrings(s);
    
    printf("[");
    for (int i = 0; i < result->count; i++) {
        printf("\"%s\"", result->strings[i]);
        if (i < result->count - 1) printf(", ");
        free(result->strings[i]);
    }
    printf("]\n");
    
    free(result->strings);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2)

2^n possible partitions, each taking O(n^2) to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current partition and character positions

⚡ Linearithmic Space

34.2K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler