Length of the Longest Valid Substring

Length of the Longest Valid Substring - Problem

You are given a string word and an array of strings forbidden.

A string is called valid if none of its substrings are present in forbidden.

Return the length of the longest valid substring of the string word.

A substring is a contiguous sequence of characters in a string, possibly empty.

Input & Output

Example 1 — Basic Case

$ Input: word = "cbaaaabc", forbidden = ["aaa", "cb"]

› Output: 4

💡 Note: Valid substrings include "c", "b", "a", "aa", "aaaa", "b", "c", "ba", "bc". The longest is "aaaa" with length 4. Substrings containing "aaa" or "cb" are invalid.

Example 2 — No Forbidden

$ Input: word = "leetcode", forbidden = []

› Output: 8

💡 Note: Since no strings are forbidden, the entire string "leetcode" is valid with length 8.

Example 3 — All Invalid

$ Input: word = "aab", forbidden = ["a"]

› Output: 1

💡 Note: Only valid substring is "b" since any substring containing "a" is forbidden. Maximum length is 1.

Constraints

1 ≤ word.length ≤ 10⁴
0 ≤ forbidden.length ≤ 10⁵
1 ≤ forbidden[i].length ≤ 10
word and forbidden[i] consist of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to use a sliding window approach where we check each possible starting position and expand as far as possible without including forbidden substrings. The optimal approach uses efficient string matching to find the longest valid substring. Best approach is sliding window with hash set lookup. Time: O(n² × m × k), Space: O(m × k)

Common Approaches

✓ Brute Force

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

Generate all possible substrings of word and check if each one contains any forbidden substring. Keep track of the maximum length valid substring found.

Sliding Window

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

Use a sliding window approach where we expand the right pointer and contract the left pointer when we encounter a forbidden substring. This avoids checking all possible substrings.

Brute Force — Algorithm Steps

Step 1: Generate all possible substrings
Step 2: For each substring, check if it contains any forbidden string
Step 3: Track maximum length of valid substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings

Check Each Substring

Verify no forbidden strings exist within

Track Maximum

Keep the longest valid substring length

Code -

solution.c — C

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

int solution(char* word, char forbidden[][100], int forbiddenSize) {
    int maxLength = 0;
    int n = strlen(word);
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            bool isValid = true;
            int substringLen = j - i + 1;
            
            // Check if substring contains any forbidden string
            for (int k = i; k <= j && isValid; k++) {
                for (int l = k; l <= j; l++) {
                    int currentLen = l - k + 1;
                    char temp[1001];
                    strncpy(temp, word + k, currentLen);
                    temp[currentLen] = '\0';
                    
                    for (int f = 0; f < forbiddenSize; f++) {
                        if (strcmp(temp, forbidden[f]) == 0) {
                            isValid = false;
                            break;
                        }
                    }
                    if (!isValid) break;
                }
            }
            
            if (isValid && substringLen > maxLength) {
                maxLength = substringLen;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char word[1001];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    
    char line[10001];
    fgets(line, sizeof(line), stdin);
    
    char forbidden[100][100];
    int forbiddenSize = 0;
    
    // Simple JSON array parsing
    char* token = strtok(line, "[],\"");
    while (token != NULL && forbiddenSize < 100) {
        if (strlen(token) > 0 && strcmp(token, " ") != 0) {
            strcpy(forbidden[forbiddenSize++], token);
        }
        token = strtok(NULL, "[],\"");
    }
    
    printf("%d\n", solution(word, forbidden, forbiddenSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × m × k)

O(n²) substrings, each takes O(n×m×k) to check against m forbidden strings of average length k

⚠ Quadratic Growth

Space Complexity

O(m × k)

Hash set to store forbidden strings

✓ Linear Space

34.0K Views

Medium Frequency

~25 min Avg. Time

850 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler