Select K Disjoint Special Substrings

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: true

💡 Note: We have special substrings like "a", "b", "c", "d", "ab", "cd", etc. We can select 3 disjoint ones: "a" (position 0), "b" (position 1), and "d" (position 3). These don't overlap and each character appears only within its respective substring.

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

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

✓ Brute Force (Generate All Combinations)

⏱️ Time: O(n³ × C(m,k)) Space: O(n²)

This approach generates all possible substrings of the input string, identifies which ones are special (characters don't appear elsewhere), then checks all possible combinations of k disjoint substrings to see if any valid combination exists.

Optimized Greedy Approach

⏱️ Time: O(n² + m log m) Space: O(n + m)

This optimal approach first identifies all characters and their positions, then finds all special substrings by checking character constraints efficiently. Finally, it uses a greedy algorithm to select k disjoint special substrings by prioritizing shorter substrings to maximize selection options.

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all possible substrings of the input string
For each substring, check if it's special by verifying its characters don't appear outside
Generate all combinations of k special substrings
Check if any combination consists of disjoint (non-overlapping) substrings
Return true if such a combination exists, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings of the input string

Check Special Property

For each substring, verify characters don't appear elsewhere

Find Combinations

Generate all possible combinations of k special substrings

Verify Disjoint

Check if any combination has non-overlapping intervals

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Interval;

static Interval specialSubstrings[1000000];
static Interval current[1000];

bool checkCombinations(int numSubstrings, int k, int start, int currentSize) {
    if (currentSize == k) {
        // Check if current combination is disjoint
        Interval intervals[1000];
        memcpy(intervals, current, k * sizeof(Interval));
        
        // Sort intervals
        for (int i = 0; i < k - 1; i++) {
            for (int j = i + 1; j < k; j++) {
                if (intervals[i].start > intervals[j].start) {
                    Interval temp = intervals[i];
                    intervals[i] = intervals[j];
                    intervals[j] = temp;
                }
            }
        }
        
        for (int i = 0; i < k - 1; i++) {
            if (intervals[i].end >= intervals[i + 1].start) {
                return false;
            }
        }
        return true;
    }
    
    for (int i = start; i < numSubstrings; i++) {
        current[currentSize] = specialSubstrings[i];
        if (checkCombinations(numSubstrings, k, i + 1, currentSize + 1)) {
            return true;
        }
    }
    
    return false;
}

bool canSelectKDisjointSpecialSubstrings(char* s, int k) {
    int n = strlen(s);
    if (k == 0) return true;
    
    // Find all special substrings
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (j - i == n) continue; // Skip entire string
            
            bool isSpecial = true;
            
            // Check if characters appear outside substring
            for (int pos = i; pos < j; pos++) {
                for (int idx = 0; idx < n; idx++) {
                    if ((idx < i || idx >= j) && s[idx] == s[pos]) {
                        isSpecial = false;
                        break;
                    }
                }
                if (!isSpecial) break;
            }
            
            if (isSpecial) {
                specialSubstrings[count].start = i;
                specialSubstrings[count].end = j - 1;
                count++;
            }
        }
    }
    
    // Check all combinations of k special substrings
    return checkCombinations(count, k, 0, 0);
}

int main() {
    char s[1001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    
    scanf("%d", &k);
    
    printf("%s\n", canSelectKDisjointSpecialSubstrings(s, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × C(m,k))

O(n²) substrings, O(n) to check if special, O(C(m,k)) combinations where m is number of special substrings

⚠ Quadratic Growth

Space Complexity

O(n²)

Store all possible substrings and their special status

⚠ Quadratic 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

Brute Force (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler