Find all good strings problem in Data Structure

Problem Statement:

Given the strings s1 and s2 of size n and the string evil, return the number of good strings. A good string has size n, it is alphabetically greater than or equal to s1, it is alphabetically smaller than or equal to s2, and it does not contain the string evil as a substring. Since the answer can be a huge number, return this modulo 10^9 + 7.

Java Approach Using HashMap

import java. util.*; 
public class GoodStringsFinder {
    static final int MOD = 1_000_000_000 + 7;
   //Create A HashMap with the name Index
    Map<String, Integer> index = new HashMap<>();
    HashMap[][][] memo;
    String A;
    String Z; 
    public int findGoodStrings(int n, String s1, String s2, String evil) {
        A = generate(n, 'a');
        Z = generate(n, 'z'); 
        memo = new HashMap[4][4][n + 1];
     //fill the hashmap with the required key values
       index.put(s1, 0);
        index.put(s2, 1);
        index.put(A, 2);
        index.put(Z, 3);
        return f(n, s1, s2, evil, Collections.emptyList());
    }
    private int f(int n, String s1, String s2, String evil, List<Integer> evilCandidates) {
        if (!evilCandidates.isEmpty() && evilCandidates.get(0) == evil.length()) {
            return 0;
        }	
       //if n equals 0, then we have to return 1
 if (n == 0) {
            return 1;
        }
        HashMap map = memo[index.get(s1)][index.get(s2)][n];
        String key = evilCandidates.toString();
     //if the map is not empty and the map has to contain the key, then we have to return the value of the key
   if (map != null && map.containsKey(key)) {
            return (int) map.get(key);
        }
        int k = s1.length() - n;
        long total = 0;
        char c1 = s1.charAt(k), c2 = s2.charAt(k);
        for (char s = c1; s <= c2; s++) {
            String left = s == c1 ? s1 : A;
            String right = s == c2 ? s2 : Z;     
List<Integer> nextEvil = new ArrayList<>();
            for (int c : evilCandidates) {
                if (s == evil.charAt(c)) {      
nextEvil.add(c + 1);
                }
            }
            if (s == evil.charAt(0)) {
                nextEvil.add(1);
            }
            total += f(n - 1, left, right, evil, nextEvil);
        }
        int res = (int) (total % MOD); 
        if (map == null) {
            map = new HashMap<>();
memo[index.get(s1)][index.get(s2)][n] = map;
        }
        map.put(key, res);
        return res;
    }
    static String generate(int count, char c) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < count; i++) {
sb.append(c);
        }
        return sb.toString();
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); 
System.out.println("Enter the length of the string:");
        int n = scanner.nextInt();
System.out.println("Enter the lower bound string:");
        String s1 = scanner.next();
System.out.println("Enter the upper bound string:");
        String s2 = scanner.next();
System.out.println("Enter the evil string:");
        String evil = scanner.next();
GoodStringsFinder finder = new GoodStringsFinder();
        int result = finder.findGoodStrings(n, s1, s2, evil); 
System.out.println("Number of good strings: " + result); 
scanner.close();
    }
}

Output:

Find all good strings problem in Data Structure

Code Explanation:

This Java code implements a solution to find the number of good strings within a given range and avoid a specified evil string. It employs dynamic programming with memoization to efficiently explore all possible combinations. The findGoodStrings method initializes necessary data structures and starts the recursion.
The f method handles the recursive exploration and memoization of subproblems. It iterates through all characters within the range for each position of the string, keeping track of evil string matches using a list of candidates.
The generate method constructs strings of specified lengths with repeated characters. Finally, the main method takes user input for string lengths and bounds and then outputs the result.

Time Complexity:

The time complexity of the findGoodStrings method is O2(n * m^2 * s^2), where n is the length of the string, m is the number of ciphers in the alphabet (26 in this instance), and s is the length of the evil string.
The time complexity of the f method is O(n * m ^2), where n denotes the length of the string and m represents the number of characters in the alphabet.

Space Complexity:

The space complexity is O(n * s ^2 * m), where n is the length of the string, s is the size of the alphabet, and m is the evil string length.

Drawback:

However, given the high space complexity of this option, especially when dealing with huge inputs, there may be better choices of approach. By using a variable length array for memoizing intermediate results (memo) and another hashmap index (index) for storing indices, memory issues with regard to large inputs may arise.
Moreover, a program with such an algorithm may experience stack overflow errors with fairly big values of the input strings, as each recursive call requires stack space. Thus, the solution serves as a base for the provided- Dynamic Programming tool to solve the problem more effectively.

Java Approach Using Dynamic Programming +KMP Algorithm

import java. util.Scanner; 
public class GoodStrings {
    Integer[][][][] dp;
    int mod = 1000000007;
    int[] lps; 
    // Function to compute the modular addition
    private int add(int a, int b) {
        return (a % mod + b % mod) % mod;
    }
    // Recursive function to find the count of good strings
    private int solve(char[] s1, char[] s2, int cur, boolean isStrictLower, boolean isStrictUpper, char[] evil, int evI) {
        // Base case: All characters in the evil string are matched
        if (evI == evil. length) return 0;
        // Base case: Reached the end of the string
        if (cur == s2.length) return 1;
        // Check if the value is already computed
        if (dp[cur][isStrictLower ? 1 : 0][isStrictUpper ? 1 : 0][evI] != null)
            return dp[cur][isStrictLower ? 1 : 0][isStrictUpper ? 1 : 0][evI]; 
        // Define the range for character comparison
        char start = isStrictLower ? s1[cur] : 'a';
        char end = isStrictUpper ? s2[cur] : 'z';
        int res = 0;
        // Iterate through the range of characters
        for (char ch = start; ch <= end; ch++) {
            if (evil[evI] == ch)
                res = add(res, solve(s1, s2, cur + 1, isStrictLower && ch == start, isStrictUpper && ch == end, evil, evI + 1));
            else {
                int j = evI;
                // Compute the Longest Prefix Suffix
                while (j > 0 && evil[j] != ch) j = lps[j - 1];
                if (ch == evil[j]) j++;
                // Recur with the updated prefix length
                res = add(res, solve(s1, s2, cur + 1, isStrictLower && ch == start, isStrictUpper && ch == end, evil, j));
            }
        }
        // Store and return the result
        return dp[cur][isStrictLower ? 1 : 0][isStrictUpper ? 1 : 0][evI] = res;
    }
    // Function to initialize and call the recursive function
    public int findGoodStrings(int n, String s1, String s2, String evil) {
        char[] arr = s1.toCharArray();
        char[] brr = s2.toCharArray();
        char[] crr = evil.toCharArray();
        // Compute the Longest Prefix Suffix array for evil string
        lps = new int[crr.length];
        for (int i = 1, j = 0; i < crr.length; i++) {
            while (j > 0 && crr[i] != crr[j]) j = lps[j - 1];
            if (crr[i] == crr[j]) lps[i] = ++j;
        }
        // Initialize the dp array
        dp = new Integer[n][2][2][crr.length];
        // Call the recursive function
        return solve(arr, brr, 0, true, true, crr, 0);
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); 
        // Input the length of strings and the strings themselves
System.out.print("Enter the length of strings n: ");
    //input the length n of the string size
    int n = scanner.nextInt();
   //input the string 1
System.out.print("Enter the first string s1: ");
        String s1 = scanner.next();
       //input the string 2
System.out.print("Enter the second string s2: ");
        String s2 = scanner.next();
       //input the evil string
System.out.print("Enter the evil string: ");
        String evil = scanner.next();
        // Create an instance of the Solution class
        Solution solution = new Solution();
        // Compute the count of good strings
        int result = solution.findGoodStrings(n, s1, s2, evil);
        // Output the result
System.out.println("Result: " + result); 
        // Close the scanner
scanner.close();
    }
}

Output:

Code Explanation:

This code calculates the count of "good strings" within the range defined by two strings, s1 and s2. A "good string" doesn't contain any substring matching an "evil string." It utilizes dynamic programming with memorization for optimization.
The solve function recursively explores all possible character combinations within the given range, ensuring each string generated avoids containing any substring that matches the evil string.
The Longest Prefix Suffix (LPS) array is computed for the evil string to optimize substring comparison.
The solution efficiently handles character comparisons, considering the lower and upper bounds of each character position in the strings.

Time Complexity:

The time complexity is O(n * m * k * l), in which n is the string length, m is the evil string length, k is the size of the alphabet, and l represents the number of recursive calls.

Space Complexity: