Count Pairs of Equal Substrings With Minimum Difference

Count Pairs of Equal Substrings With Minimum Difference - Problem

Count Pairs of Equal Substrings With Minimum Difference

You're given two strings firstString and secondString containing only lowercase English letters. Your task is to find matching substrings between these two strings and count specific quadruples.

A quadruple (i, j, a, b) is valid if:

0 <= i <= j < firstString.length
0 <= a <= b < secondString.length
The substring firstString[i:j+1] equals secondString[a:b+1]
j - a is the minimum possible value among all valid quadruples

Goal: Return the count of quadruples that satisfy all conditions, especially having the minimum j - a value.

Example: If firstString = "abab" and secondString = "ab", we need to find all matching substrings and then count only those with minimum difference j - a.

Input & Output

example_1.py — Basic Match

$ Input: firstString = "abab", secondString = "ab"

› Output: 1

💡 Note: The substring "ab" from firstString[1:2] matches secondString[0:1]. The quadruple (1,2,0,1) gives j-a = 2-0 = 2. This is the minimum possible difference, so we count 1 quadruple.

example_2.py — Multiple Matches

$ Input: firstString = "ab", secondString = "abab"

› Output: 3

💡 Note: We have matches: "a"(0,0,0,0) with diff=0, "a"(0,0,2,2) with diff=-2, "b"(1,1,1,1) with diff=0, "b"(1,1,3,3) with diff=-2, "ab"(0,1,0,1) with diff=1, "ab"(0,1,2,3) with diff=-1. Minimum difference is -2, and there are 2 quadruples with this difference.

example_3.py — No Matches

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

› Output: 0

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

Visualization

Tap to expand

Understanding the Visualization

Scan by Book Size

Process books (substrings) starting from single letters, then pairs, then larger groups

Create Quick Reference

Build a catalog of all books on the second shelf for current size

Find Matches

For each book on the first shelf, quickly look up matches in the catalog

Calculate Reading Order

Compute j-a difference (position relationship between matched books)

Track Best Arrangement

Keep only matches with the minimum reading order difference

Key Takeaway

🎯 Key Insight: By processing substrings length by length and tracking the minimum j-a difference dynamically, we avoid storing all possible matches and achieve optimal efficiency.

Time & Space Complexity

Time Complexity

⏱️

O(n^3)

Three nested loops for length, starting positions, and string comparison

⚠ Quadratic Growth

Space Complexity

O(n^2)

Hash map stores substrings of current length only

⚠ Quadratic Space

Constraints

1 <= firstString.length, secondString.length <= 100
firstString and secondString consist of only lowercase English letters
The minimum difference j - a can be negative
All quadruples must satisfy the substring equality condition

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses a one-pass hash table strategy that processes substrings by length while tracking the minimum j-a difference dynamically. This avoids storing all possible matches and achieves O(n³) time complexity with efficient space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Substrings)	O(n^4)	O(n^2)	Generate all possible substrings from both strings and find matches
Two-Pass Hash Table Approach	O(n^3)	O(n^2)	First pass builds hash map of second string substrings, second pass finds matches
One-Pass Hash Table (Optimal)	O(n^3)	O(n^2)	Build hash map and find matches simultaneously while tracking minimum difference

Brute Force (All Substrings) — Algorithm Steps

Generate all substrings from firstString with indices (i,j)
Generate all substrings from secondString with indices (a,b)
Compare each substring pair for equality
Track minimum j-a value among equal substrings
Count quadruples with this minimum difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate First String Substrings

Extract all possible substrings from the first string with their indices

Generate Second String Substrings

Extract all possible substrings from the second string with their indices

Compare All Pairs

Compare each substring from first string with each from second string

Find Minimum Difference

Among matching pairs, identify the minimum j-a value

Count Results

Count all quadruples with the minimum difference

Code -

solution.c — C

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

int countQuadruples(char* firstString, char* secondString) {
    int n1 = strlen(firstString), n2 = strlen(secondString);
    int validQuadruples[10000][5];
    int count = 0;
    
    // Generate all possible quadruples
    for (int i = 0; i < n1; i++) {
        for (int j = i; j < n1; j++) {
            for (int a = 0; a < n2; a++) {
                for (int b = a; b < n2; b++) {
                    int len1 = j - i + 1, len2 = b - a + 1;
                    if (len1 == len2 && strncmp(firstString + i, secondString + a, len1) == 0) {
                        validQuadruples[count][0] = i;
                        validQuadruples[count][1] = j;
                        validQuadruples[count][2] = a;
                        validQuadruples[count][3] = b;
                        validQuadruples[count][4] = j - a;
                        count++;
                    }
                }
            }
        }
    }
    
    if (count == 0) return 0;
    
    // Find minimum j - a
    int minDiff = INT_MAX;
    for (int i = 0; i < count; i++) {
        if (validQuadruples[i][4] < minDiff) {
            minDiff = validQuadruples[i][4];
        }
    }
    
    // Count quadruples with minimum difference
    int result = 0;
    for (int i = 0; i < count; i++) {
        if (validQuadruples[i][4] == minDiff) {
            result++;
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    printf("%d\n", countQuadruples("example", "test"));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^4)

Four nested loops to generate and compare all substring combinations

✓ Linear Growth

Space Complexity

O(n^2)

Storage for all generated substrings

⚠ Quadratic Space

Constraints

1 <= firstString.length, secondString.length <= 100
firstString and secondString consist of only lowercase English letters
The minimum difference j - a can be negative
All quadruples must satisfy the substring equality condition

34.2K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Count Pairs of Equal Substrings With Minimum Difference

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler