Count Pairs of Equal Substrings With Minimum Difference

Count Pairs of Equal Substrings With Minimum Difference - Problem

You are given two strings firstString and secondString that are 0-indexed and consist only of lowercase English letters.

Count the number of index quadruples (i,j,a,b) that satisfy the following conditions:

0 <= i <= j < firstString.length
0 <= a <= b < secondString.length
The substring of firstString that starts at the ith character and ends at the jth character (inclusive) is equal to the substring of secondString that starts at the ath character and ends at the bth character (inclusive)
j - a is the minimum possible value among all quadruples that satisfy the previous conditions

Return the number of such quadruples.

Input & Output

Example 1 — Basic Case

$ Input: firstString = "abc", secondString = "bc"

› Output: 2

💡 Note: Matching substrings: "b" at (1,1) and (0,0) with j-a=1, "c" at (2,2) and (1,1) with j-a=1. Both achieve minimum j-a=1, so count is 2.

Example 2 — Single Character

$ Input: firstString = "a", secondString = "a"

› Output: 1

💡 Note: Only one match: "a" at (0,0) and (0,0) with j-a=0. This is the minimum, so count is 1.

Example 3 — No Matches

$ Input: firstString = "abc", secondString = "def"

› Output: 0

💡 Note: No common substrings between the two strings, so no valid quadruples exist.

Constraints

1 ≤ firstString.length, secondString.length ≤ 100
firstString and secondString consist only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to find all matching substring pairs between the two strings and identify those with minimum j-a difference. Best approach uses a two-pass method: first pass finds the minimum difference, second pass counts occurrences. Time: O(n⁴), Space: O(1).

Common Approaches

✓ Trie

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

Rolling Hash

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

Brute Force - Generate All Quadruples

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

For each possible substring from firstString, compare it with all substrings from secondString. Among matching pairs, find those with minimum j-a value.

Hash Map Optimization

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

Generate all substrings from both strings and group them by content in a hash map. For each group of equal substrings, find the minimum j-a value and count pairs achieving this minimum.

Optimized Two-Pass Approach

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

Instead of storing all matches, use two passes: first pass finds the global minimum j-a value among all matching pairs, second pass counts how many pairs achieve this minimum.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct TrieNode {
    struct TrieNode* children[26];
    int indices[1000];
    int indexCount;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    node->indexCount = 0;
    return node;
}

int solution(char words[][101], int n) {
    if (n < 2) return 0;
    
    // Build trie
    TrieNode* root = createNode();
    for (int i = 0; i < n; i++) {
        TrieNode* node = root;
        for (int j = 0; words[i][j]; j++) {
            int idx = words[i][j] - 'a';
            if (!node->children[idx]) {
                node->children[idx] = createNode();
            }
            node = node->children[idx];
            node->indices[node->indexCount++] = i;
        }
    }
    
    int count = 0;
    for (int i = 0; i < n; i++) {
        // Find all strings that have words[i] as prefix
        TrieNode* node = root;
        int valid = 1;
        for (int j = 0; words[i][j]; j++) {
            int idx = words[i][j] - 'a';
            if (!node->children[idx]) {
                valid = 0;
                break;
            }
            node = node->children[idx];
        }
        
        if (valid) {
            // Check which also have words[i] as suffix
            for (int k = 0; k < node->indexCount; k++) {
                int j = node->indices[k];
                if (j > i) {
                    int len1 = strlen(words[i]);
                    int len2 = strlen(words[j]);
                    if (len2 >= len1 && strcmp(words[j] + len2 - len1, words[i]) == 0) {
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char words[1000][101];
    int n = 0;
    
    // Remove newline if present
    line[strcspn(line, "\n")] = 0;
    
    // Skip opening bracket
    char* ptr = line + 1;
    
    // Parse each word
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']') break;
        
        // Expect opening quote
        if (*ptr == '"') {
            ptr++; // skip opening quote
            int wordLen = 0;
            // Copy until closing quote
            while (*ptr && *ptr != '"') {
                words[n][wordLen++] = *ptr++;
            }
            words[n][wordLen] = '\0';
            if (*ptr == '"') ptr++; // skip closing quote
            n++;
        }
    }
    
    int result = solution(words, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.5K Views

Medium Frequency

~25 min Avg. Time

234 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