Find Longest Self-Contained Substring

Find Longest Self-Contained Substring - Problem

Given a string s, your task is to find the length of the longest self-contained substring of s.

A substring t of a string s is called self-contained if:

t != s (the substring is not the entire string)
For every character in t, it doesn't exist in the rest of s (outside of t)

Return the length of the longest self-contained substring of s if it exists, otherwise return -1.

Input & Output

Example 1 — Basic Self-Contained

$ Input: s = "abcdef"

› Output: 5

💡 Note: The substring "abcde" (length 5) is self-contained because none of its characters (a,b,c,d,e) appear in the remaining part "f"

Example 2 — No Self-Contained

$ Input: s = "aaa"

› Output: -1

💡 Note: No substring can be self-contained because character 'a' appears throughout the entire string

Example 3 — Multiple Options

$ Input: s = "abcabc"

› Output: -1

💡 Note: No substring can be self-contained because characters 'a', 'b', 'c' each appear in both halves of the string, violating the self-contained requirement

Constraints

1 ≤ s.length ≤ 10³
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18

The key insight is that a substring is self-contained when all its characters appear only within its boundaries and nowhere else in the string. The best approach uses character position tracking to efficiently verify boundaries. Time: O(n²), Space: O(k) where k is unique characters.

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Prefix Sum

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n³) Space: O(1)

For each possible substring, count character frequencies in the substring and in the rest of the string. A substring is self-contained if no character appears both inside and outside it.

Optimized Sliding Window

⏱️ Time: O(n²) Space: O(k)

Track the first and last occurrence of each character. A substring is self-contained if all characters in it have their first and last occurrences within the substring boundaries.

Two Pass with Hash Map

⏱️ Time: O(n³) Space: O(k)

First pass builds a frequency map of all characters. Second pass checks each substring by comparing character counts inside vs outside the substring boundaries.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

long long solution(int* nums, int n) {
    qsort(nums, n, sizeof(int), compare);
    
    // Try removing largest elements one by one
    for (int removeCount = 0; removeCount <= n - 3; removeCount++) {
        int subsetSize = n - removeCount;
        if (subsetSize >= 3) {
            long long largest = nums[subsetSize - 1];
            long long sumOthers = 0;
            for (int i = 0; i < subsetSize - 1; i++) {
                sumOthers += nums[i];
            }
            
            if (largest < sumOthers) {
                return largest + sumOthers;
            }
        }
    }
    
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char *ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char *token = strtok(ptr, ",]");
        while (token && n < 1000) {
            nums[n++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    long long result = solution(nums, n);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

24.5K Views

Medium Frequency

~25 min Avg. Time

680 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