Skip to main content

Select K Disjoint Special Substrings - Solution & Explanation

MediumHash TableStringDynamic ProgrammingGreedy4 min readAsked at: Amazon
Practice this problem

Problem Statement

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

A special substring is a substring where:

  • Any character present inside the substring should not appear outside it in the string.
  • The substring is not the entire string s.

Note that all k substrings must be disjoint, meaning they cannot overlap.

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

 

Example 1:

Input: s = "abcdbaefab", k = 2

Output: true

Explanation:

  • We can select two disjoint special substrings: "cd" and "ef".
  • "cd" contains the characters 'c' and 'd', which do not appear elsewhere in s.
  • "ef" contains the characters 'e' and 'f', which do not appear elsewhere in s.

Example 2:

Input: s = "cdefdc", k = 3

Output: false

Explanation:

There can be at most 2 disjoint special substrings: "e" and "f". Since k = 3, the output is false.

Example 3:

Input: s = "abeabe", k = 0

Output: true

 

Constraints:

  • 2 <= n == s.length <= 5 * 104
  • 0 <= k <= 26
  • s consists only of lowercase English letters.

Approach Overview

Problem Overview: Given a string s and an integer k, select k disjoint substrings such that each substring is special. A substring is special when every character inside it appears only within that substring in the original string. The goal is to determine whether at least k such non‑overlapping substrings can be chosen.

Approach 1: Brute Force Substring Validation (O(n^3) time, O(1) space)

Generate every possible substring using two nested loops. For each substring, verify whether it is special by checking the first and last occurrence of every character in the substring against the boundaries of the substring. If any character appears outside the range, the substring is invalid. Store all valid substrings and try selecting k non‑overlapping ones using another pass or backtracking. This approach demonstrates the definition clearly but becomes impractical because validating every substring requires scanning characters repeatedly.

Approach 2: Character Interval Expansion + Greedy Selection (O(n log n) time, O(n) space)

First compute the first and last occurrence of every character using a hash table. For each index that represents the first appearance of a character, expand an interval starting at that index and extend it to the farthest last occurrence of all characters encountered while scanning. If expansion ever moves before the starting index of any character, the interval cannot form a valid special substring and is discarded. This produces candidate intervals where all character occurrences are contained inside the interval.

Once valid intervals are collected, treat them like a classic non‑overlapping interval scheduling problem. Sort the intervals by ending index using sorting, then greedily pick intervals whose start is greater than the end of the previously chosen interval. Count how many intervals can be selected. If the count is at least k, the answer is true. The key insight is that minimal valid intervals guarantee character isolation, and greedy earliest‑finish selection maximizes the number of disjoint substrings.

Approach 3: Dynamic Programming on Intervals (O(n log n) time, O(n) space)

Instead of greedy selection, you can sort valid intervals and run a dynamic programming solution similar to weighted interval scheduling. Let dp[i] represent the maximum number of valid substrings that can be chosen considering the first i intervals. For each interval, either include it (and add 1 plus the best compatible interval before it) or skip it. Binary search finds the previous non‑overlapping interval efficiently. This approach is useful if the problem variant later adds weights or additional constraints.

Recommended for interviews: Interval expansion followed by greedy interval scheduling. It runs in near linear time, clearly demonstrates understanding of character boundaries, and uses a classic greedy pattern that interviewers expect. The brute force approach helps explain the definition of a special substring, but the interval + greedy solution shows algorithmic maturity.

Solutions for this problem are being prepared.

Try solving it yourself

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Brute Force Substring ValidationO(n^3)O(1)Conceptual understanding or very small strings
Interval Expansion + Greedy SelectionO(n log n)O(n)General optimal solution for selecting maximum non-overlapping special substrings
Dynamic Programming on IntervalsO(n log n)O(n)Useful if the problem variant introduces weights or additional constraints

Video Solution

3458. Select K Disjoint Special Substrings | Greedy | Sorting • Aryan Mittal • 2,979 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Select K Disjoint Special Substrings easy or hard?
The problem is rated Medium but has a relatively low acceptance rate because identifying valid substring intervals is tricky. Once intervals are constructed correctly, the rest reduces to a standard greedy interval scheduling problem.
Select K Disjoint Special Substrings Python/Java solution
Typical implementations compute character boundaries with an array or map, generate valid intervals by expanding ranges, then sort intervals by end index. A greedy loop selects the maximum number of non-overlapping substrings and checks whether the count is at least k. The same logic works consistently in Python, Java, C++, and Go.
How to solve Select K Disjoint Special Substrings in O(n)?
Compute the first and last occurrence of each character and expand intervals only from first occurrences. Each character is processed a constant number of times while expanding intervals. If interval sorting is avoided using bucket ordering or alphabet constraints, the approach can approach O(n) time in practice, though most implementations remain O(n log n).
What is the best approach for Select K Disjoint Special Substrings?
The most effective solution builds minimal valid character intervals and then selects non-overlapping ones using a greedy interval scheduling strategy. First compute first and last occurrences of every character, expand intervals to include all occurrences of characters inside them, then sort by end index and greedily pick intervals. This runs in O(n log n) time and O(n) space.
Is Select K Disjoint Special Substrings asked at Google/Amazon/Meta?
Interval scheduling combined with character boundary preprocessing appears frequently in interviews at large tech companies. Variants of this pattern show up at companies like Google and Amazon because they test greedy reasoning, string preprocessing, and interval reasoning in one problem.
What data structure is used in Select K Disjoint Special Substrings?
The solution mainly uses hash tables or arrays to store the first and last occurrence of characters. After generating candidate intervals, sorting and greedy selection are applied. Some implementations also use dynamic programming with binary search for interval compatibility.
What is the time complexity of Select K Disjoint Special Substrings?
The optimal solution runs in O(n log n) time due to sorting candidate intervals. Building character boundaries and expanding intervals takes O(n). Space complexity is O(n) for storing interval candidates and character occurrence data.

Ready to solve this problem?

Practice Select K Disjoint Special Substrings with our built-in code editor and test cases.

Practice on FleetCode