Find Maximum Number of Non Intersecting Substrings

Find Maximum Number of Non Intersecting Substrings - Problem

You're given a string word and need to find the maximum number of non-overlapping substrings that satisfy two conditions:

Each substring must be at least 4 characters long
Each substring must start and end with the same letter

The key challenge is to maximize the count while ensuring no two selected substrings overlap (share any characters).

Example: In the string "abcadefgag", we could select "abca" (positions 0-3) and "gag" (positions 7-9) for a total of 1 valid substring, since "gag" is only 3 characters long.

Think of it as placing non-overlapping brackets around valid substrings to maximize the number of brackets you can place!

Input & Output

example_1.py — Basic Case

$ Input: word = "abcadefgag"

› Output: 1

💡 Note: Only one valid substring exists: "abca" (positions 0-3). The substring "gag" is only 3 characters long, so it doesn't meet the minimum length requirement of 4.

example_2.py — Multiple Options

$ Input: word = "aabcaabdaea"

› Output: 2

💡 Note: We can select "aabca" (0-4) and "aea" (8-10). Wait, "aea" is only 3 chars, so invalid. Actually, we can take "aabca" (0-4) and "aabda" doesn't work either. The answer is 1 with just "aabca".

example_3.py — No Valid Substrings

$ Input: word = "abcdef"

› Output: 0

💡 Note: No character appears at both the start and end of any substring of length ≥ 4, so no valid substrings exist.

Constraints

1 ≤ word.length ≤ 2000
word consists of lowercase English letters only
Each valid substring must be at least 4 characters long
Valid substrings must start and end with the same letter

Visualization

Tap to expand

Understanding the Visualization

Scan Left to Right

Move through the string character by character, looking for opportunities

Find Valid Endpoints

When you encounter a character, look ahead to find the earliest matching character at distance ≥4

Make Greedy Choice

Immediately select the shortest valid substring to leave maximum space for future selections

Skip Covered Positions

Jump past the selected substring and continue the process

Key Takeaway

🎯 Key Insight: Greedy selection of shortest valid substrings maximizes the number of non-overlapping selections by preserving the most space for future opportunities.

Asked in

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

The optimal approach is to use a greedy algorithm: scan left to right and greedily select the shortest valid substring at each opportunity. This works because shorter selections always leave more room for future selections, maximizing the total count. Alternatively, model it as an interval scheduling problem using dynamic programming with binary search for O(n²log n) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Interval Scheduling (Dynamic Programming)	O(n² log n)	O(n²)	Find all valid intervals, then use DP to find maximum non-overlapping set
Brute Force (Generate All Combinations)	O(2^k)	O(k + n)	Generate all valid substrings, then find maximum non-overlapping set

Interval Scheduling (Dynamic Programming) — Algorithm Steps

Find all valid substrings (intervals) in O(n²) time
Sort intervals by their end positions for optimal processing
Use DP where dp[i] = maximum intervals we can select from first i intervals
For each interval, decide to take it (plus best before it) or skip it

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Valid Intervals

Extract all substrings ≥4 chars with matching endpoints

Sort by End Position

Arrange intervals by their ending positions for optimal processing

DP with Binary Search

For each interval, find the latest non-overlapping one before it

Choose Maximum

Decide whether to include current interval based on DP values

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Interval;

int compare(const void *a, const void *b) {
    return ((Interval*)a)->end - ((Interval*)b)->end;
}

int binarySearch(Interval* intervals, int idx) {
    int targetEnd = intervals[idx].start - 1;
    int left = 0, right = idx - 1, result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (intervals[mid].end <= targetEnd) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int maxNonIntersectingSubstrings(char* word) {
    int n = strlen(word);
    Interval intervals[n*n];
    int count = 0;
    
    // Find all valid intervals
    for (int i = 0; i < n; i++) {
        for (int j = i + 4; j <= n; j++) {
            if (word[i] == word[j-1]) {
                intervals[count].start = i;
                intervals[count].end = j-1;
                count++;
            }
        }
    }
    
    if (count == 0) return 0;
    
    qsort(intervals, count, sizeof(Interval), compare);
    
    int dp[count];
    dp[0] = 1;
    
    for (int i = 1; i < count; i++) {
        dp[i] = dp[i-1];
        
        int prev = binarySearch(intervals, i);
        int takeCurrent = 1 + (prev != -1 ? dp[prev] : 0);
        if (takeCurrent > dp[i]) dp[i] = takeCurrent;
    }
    
    return dp[count-1];
}

int main() {
    char word[1000];
    fgets(word, sizeof(word), stdin);
    
    int len = strlen(word);
    if (word[len-1] == '\n') word[len-1] = '\0';
    if (word[0] == '"') {
        memmove(word, word+1, len-1);
        len = strlen(word);
        if (word[len-1] == '"') word[len-1] = '\0';
    }
    
    printf("%d\n", maxNonIntersectingSubstrings(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n²) to find all intervals, O(n log n) to sort, O(n log n) for DP with binary search

⚠ Quadratic Growth

Space Complexity

O(n²)

In worst case, O(n²) intervals can be formed, plus O(n) for DP array

⚠ Quadratic Space

28.5K 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

Interval Scheduling (Dynamic Programming) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler