Find All Good Strings - Practice Coding Problems

Find All Good Strings - Problem

You're tasked with finding "good strings" that satisfy multiple strict criteria. Given three strings - s1, s2 (both of length n), and evil - you need to count all strings of length n that are:

Lexicographically ≥ s1 (comes at or after s1 in dictionary order)
Lexicographically ≤ s2 (comes at or before s2 in dictionary order)
Does NOT contain evil as a substring

For example, if s1 = "aa", s2 = "da", and evil = "b", then valid strings include "aa", "ac", "ca", etc., but NOT "ab" (contains evil) or "ea" (> s2).

Return the count modulo 10⁹ + 7 since the answer can be enormous.

Input & Output

example_1.py — Basic Case

$ Input: n = 2, s1 = "aa", s2 = "da", evil = "b"

› Output: 51

💡 Note: All strings from 'aa' to 'da' that don't contain 'b'. This includes 'aa', 'ac', 'ad', ..., 'ca', 'cc', 'cd', ..., 'da' but excludes any string with 'b' like 'ab', 'ba', 'bb', etc.

example_2.py — Evil at Start

$ Input: n = 8, s1 = "leetcode", s2 = "leetgoes", evil = "leet"

› Output: 0

💡 Note: Since both s1 and s2 start with 'leet' (which is the evil string), any valid string in the range must also start with 'leet', making it impossible to avoid the evil substring.

example_3.py — Single Character Range

$ Input: n = 2, s1 = "gx", s2 = "gz", evil = "x"

› Output: 2

💡 Note: Valid strings are 'gy' and 'gz'. 'gx' is excluded because it contains the evil character 'x'.

Visualization

Tap to expand

Understanding the Visualization

Setup KMP Automaton

Create a state machine that tracks how close we are to forming the forbidden pattern

Dynamic Programming

Build strings position by position, maintaining bounds and pattern state

Pruning

Skip any path that would complete the forbidden pattern

Count Valid Strings

Sum up all successful paths that reach the end without violations

Key Takeaway

🎯 Key Insight: By combining digit DP for lexicographic constraints with KMP automaton for pattern avoidance, we can efficiently explore only valid string constructions without generating invalid paths.

Time & Space Complexity

Time Complexity

⏱️

O(n × m × 8)

n positions, m KMP states, 8 combinations of tight bounds, constant work per state

✓ Linear Growth

Space Complexity

O(n × m × 8)

Memoization table with dimensions for position, KMP state, and tight flags

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 500
1 ≤ evil.length ≤ 50
s1.length == s2.length == n
s1 ≤ s2 lexicographically
s1, s2, and evil consist of lowercase English letters only

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 f Meta 3

The optimal solution combines Dynamic Programming with KMP String Matching to efficiently count valid strings. We use digit DP to handle lexicographic bounds while maintaining a KMP automaton state to track potential evil substring matches, achieving O(n × m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming + KMP (Optimal)	O(n × m × 8)	O(n × m × 8)	Use digit DP with KMP automaton to efficiently build valid strings
Brute Force (Generate All Strings)	O(26^n × n × m)	O(n)	Generate all possible strings of length n and check each constraint

Dynamic Programming + KMP (Optimal) — Algorithm Steps

Build KMP failure function for the evil string to create automaton
Use digit DP with states: position, tight_lower, tight_upper, kmp_state
For each position, try all valid characters within bounds
Update KMP state to track partial matches with evil string
Reject paths where KMP state indicates complete evil match
Memoize results to avoid recomputation

Visualization

Tap to expand

Step-by-Step Walkthrough

Build KMP Failure Function

Create automaton for evil string pattern matching

Initialize DP States

Start with position=0, KMP state=0, both bounds tight

Try Valid Characters

For each position, try characters within lexicographic bounds

Update KMP State

Use failure function to efficiently update pattern matching state

Prune Invalid Paths

Skip branches that would complete the evil pattern

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 505

int failure[MAXN];
char evil[MAXN];
int n, evil_len;
char s1[MAXN], s2[MAXN];
int memo[MAXN][MAXN][2][2];
int memo_set[MAXN][MAXN][2][2];

void buildFailureFunction() {
    int j = 0;
    for (int i = 1; i < evil_len; i++) {
        while (j > 0 && evil[i] != evil[j]) {
            j = failure[j - 1];
        }
        if (evil[i] == evil[j]) {
            j++;
        }
        failure[i] = j;
    }
}

int dp(int pos, int kmpState, int tightLower, int tightUpper) {
    if (kmpState == evil_len) return 0;
    if (pos == n) return 1;
    
    if (memo_set[pos][kmpState][tightLower][tightUpper]) {
        return memo[pos][kmpState][tightLower][tightUpper];
    }
    
    long long result = 0;
    char startChar = tightLower ? s1[pos] : 'a';
    char endChar = tightUpper ? s2[pos] : 'z';
    
    for (char c = startChar; c <= endChar; c++) {
        int newTightLower = tightLower && (c == s1[pos]);
        int newTightUpper = tightUpper && (c == s2[pos]);
        
        int newKmpState = kmpState;
        while (newKmpState > 0 && evil[newKmpState] != c) {
            newKmpState = failure[newKmpState - 1];
        }
        if (evil[newKmpState] == c) {
            newKmpState++;
        }
        
        if (newKmpState < evil_len) {
            result = (result + dp(pos + 1, newKmpState, newTightLower, newTightUpper)) % MOD;
        }
    }
    
    memo_set[pos][kmpState][tightLower][tightUpper] = 1;
    return memo[pos][kmpState][tightLower][tightUpper] = result;
}

int findGoodStrings() {
    memset(memo_set, 0, sizeof(memo_set));
    buildFailureFunction();
    return dp(0, 0, 1, 1);
}

int main() {
    scanf("%d %s %s %s", &n, s1, s2, evil);
    evil_len = strlen(evil);
    printf("%d\n", findGoodStrings());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × 8)

n positions, m KMP states, 8 combinations of tight bounds, constant work per state

✓ Linear Growth

Space Complexity

O(n × m × 8)

Memoization table with dimensions for position, KMP state, and tight flags

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 500
1 ≤ evil.length ≤ 50
s1.length == s2.length == n
s1 ≤ s2 lexicographically
s1, s2, and evil consist of lowercase English letters only

28.0K Views

Medium Frequency

~35 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming + KMP (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler