Select K Disjoint Special Substrings - Practice Coding Problems

Select K Disjoint Special Substrings - Problem

Given a string s of length n and an integer k, determine whether it's possible to select k disjoint special substrings.

A special substring is defined as a substring where:

Any character present inside the substring should not appear anywhere else in the string
The substring is not the entire string s

All k substrings must be disjoint, meaning they cannot overlap with each other.

Example: In string "abcdef", substring "abc" is special if characters 'a', 'b', 'c' don't appear in the remaining part "def".

Return true if it's possible to select k such disjoint special substrings; otherwise, return false.

Input & Output

example_1.py — Python

$ Input: s = "abcdef", k = 2

› Output: true

💡 Note: We can select "abc" (positions 0-2) and "def" (positions 3-5). These are disjoint special substrings since characters in "abc" don't appear in "def" and vice versa.

example_2.py — Python

$ Input: s = "abcabc", k = 1

› Output: false

💡 Note: No special substring exists because every character appears multiple times in the string. For example, 'a' appears at positions 0 and 3, so any substring containing 'a' cannot be special.

example_3.py — Python

$ Input: s = "abcd", k = 3

› Output: false

💡 Note: While we have special substrings like "a", "b", "c", "d", "ab", "cd", we cannot find 3 disjoint ones. Maximum we can select is 2 disjoint substrings like "ab" and "cd".

Constraints

1 ≤ s.length ≤ 10³
0 ≤ k ≤ s.length
s consists of lowercase English letters only
Special substrings cannot be the entire string s

Visualization

Tap to expand

Understanding the Visualization

Map Character Locations

Create an index of where each character appears in the string

Identify Special Substrings

Find substrings where all characters are confined within the substring

Sort by Priority

Prioritize shorter substrings to maximize selection flexibility

Greedy Selection

Select k non-overlapping special substrings using interval scheduling

Key Takeaway

🎯 Key Insight: A substring is special if all its characters are 'isolated' within that substring. The greedy approach of selecting shorter special substrings first maximizes our ability to find k disjoint selections.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a greedy approach combined with efficient character mapping. First, build a character position map for O(1) lookups. Then identify all special substrings by checking if their characters appear only within their boundaries. Finally, sort special substrings by length and greedily select k disjoint intervals to maximize selection success.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Greedy Approach	O(n² + m log m)	O(n + m)	Find all special substrings efficiently, then greedily select k disjoint ones
Brute Force (Generate All Combinations)	O(n³ × C(m,k))	O(n²)	Generate all possible substrings and check all combinations of k disjoint special ones

Optimized Greedy Approach — Algorithm Steps

Create a character position map to track where each character appears
For each possible substring, quickly check if it's special using the position map
Sort all special substrings by length (greedy: prefer shorter ones)
Greedily select k non-overlapping substrings using interval scheduling
Return true if we can select k disjoint special substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Mapping

Build position map for O(1) character lookup

Special Detection

Efficiently check special property using position map

Sort by Length

Prefer shorter substrings to maximize selection options

Greedy Selection

Select k non-overlapping intervals greedily

Code -

solution.c — C

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

typedef struct {
    int start, end, length;
} Interval;

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

bool canSelectKDisjointSpecialSubstrings(char* s, int k) {
    int n = strlen(s);
    if (k == 0) return true;
    if (n < 2) return false;
    
    // Find all special substrings
    Interval specialSubstrings[n * n];
    int count = 0;
    
    for (int start = 0; start < n; start++) {
        for (int end = start + 1; end < n; end++) {
            if (end - start + 1 == n) continue; // Skip entire string
            
            // Check if substring [start:end+1] is special
            bool isSpecial = true;
            
            for (int i = start; i <= end && isSpecial; i++) {
                char c = s[i];
                // Check if this character appears outside [start, end]
                for (int j = 0; j < n; j++) {
                    if ((j < start || j > end) && s[j] == c) {
                        isSpecial = false;
                        break;
                    }
                }
            }
            
            if (isSpecial) {
                specialSubstrings[count].start = start;
                specialSubstrings[count].end = end;
                specialSubstrings[count].length = end - start + 1;
                count++;
            }
        }
    }
    
    if (count < k) return false;
    
    // Sort by length (greedy: prefer shorter substrings)
    qsort(specialSubstrings, count, sizeof(Interval), compareInterval);
    
    // Greedy selection of k disjoint intervals
    Interval selected[k];
    int selectedCount = 0;
    
    for (int i = 0; i < count && selectedCount < k; i++) {
        int start = specialSubstrings[i].start;
        int end = specialSubstrings[i].end;
        
        // Check if this interval overlaps with any selected interval
        bool canSelect = true;
        for (int j = 0; j < selectedCount; j++) {
            if (!(end < selected[j].start || start > selected[j].end)) {
                canSelect = false;
                break;
            }
        }
        
        if (canSelect) {
            selected[selectedCount].start = start;
            selected[selectedCount].end = end;
            selectedCount++;
        }
    }
    
    return selectedCount >= k;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* s = strtok(line, " ");
    int k = atoi(strtok(NULL, " \n"));
    
    printf("%s\n", canSelectKDisjointSpecialSubstrings(s, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + m log m)

O(n²) to find all special substrings, O(m log m) to sort them where m is number of special substrings

⚠ Quadratic Growth

Space Complexity

O(n + m)

O(n) for character position map, O(m) to store special substrings

⚡ Linearithmic Space

23.8K Views

Medium Frequency

~25 min Avg. Time

847 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

Optimized Greedy Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler