Count Prefix and Suffix Pairs II

Count Prefix and Suffix Pairs II - Problem

You are given a 0-indexed string array words.

Let's define a boolean function isPrefixAndSuffix that takes two strings, str1 and str2:

isPrefixAndSuffix(str1, str2) returns true if str1 is both a prefix and a suffix of str2, and false otherwise.

For example, isPrefixAndSuffix("aba", "ababa") is true because "aba" is a prefix of "ababa" and also a suffix, but isPrefixAndSuffix("abc", "abcd") is false.

Return an integer denoting the number of index pairs (i, j) such that i < j, and isPrefixAndSuffix(words[i], words[j]) is true.

Input & Output

Example 1 — Basic Case

$ Input: words = ["a","aba","ababa","aa"]

› Output: 4

💡 Note: Valid pairs: (0,1) "a" is prefix/suffix of "aba", (0,2) "a" is prefix/suffix of "ababa", (0,3) "a" is prefix/suffix of "aa", (1,2) "aba" is prefix/suffix of "ababa"

Example 2 — No Matches

$ Input: words = ["pa","papa","ma","mama"]

› Output: 2

💡 Note: Valid pairs: (0,1) "pa" is prefix/suffix of "papa", (2,3) "ma" is prefix/suffix of "mama"

Example 3 — Edge Case

$ Input: words = ["abab","ab"]

› Output: 0

💡 Note: No valid pairs since "abab" cannot be prefix/suffix of shorter "ab"

Constraints

1 ≤ words.length ≤ 5 × 10⁴
1 ≤ words[i].length ≤ 10⁵
words[i] consists only of lowercase English letters
The sum of lengths of all words[i] does not exceed 5 × 10⁵

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that we need to efficiently check if one string is both a prefix and suffix of another. The brute force approach checks all pairs in O(n² × m) time. Better approaches use Trie for prefix optimization or rolling hash for fast string comparison. Best approach depends on input characteristics: Trie for many common prefixes, rolling hash for fewer collisions. Time: O(n² × m), Space: O(n × m)

Common Approaches

✓ Brute Force

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

For each pair of indices (i,j) where i < j, check if words[i] is both a prefix and suffix of words[j]. This requires checking if words[j] starts with words[i] and ends with words[i].

Rolling Hash Optimization

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

Compute rolling hash values for all prefixes and suffixes of each string. For each pair (i,j), check if the hash of words[i] matches both the prefix hash and suffix hash of words[j] at the appropriate length.

Trie-Based Optimization

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

Build a Trie to store all strings, then for each string, traverse the Trie to find other strings that have it as both prefix and suffix. This reduces redundant string comparisons.

Brute Force — Algorithm Steps

Iterate through all pairs (i,j) where i < j
For each pair, check if words[i] is prefix of words[j]
Check if words[i] is suffix of words[j]
Count pairs where both conditions are true

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Pair (0,1)

Compare words[0] with words[1]

Check Pair (0,2)

Compare words[0] with words[2]

Count Matches

Count pairs where prefix and suffix match

Code -

solution.c — C

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

#define MOD 1000000007
#define BASE 31
#define MAX_WORDS 1000
#define MAX_LEN 101

static char words[MAX_WORDS][MAX_LEN];
static long long prefixHashes[MAX_WORDS][MAX_LEN];
static long long suffixHashes[MAX_WORDS][MAX_LEN];
static long long powers[MAX_LEN];

int solution(int n) {
    if (n < 2) {
        return 0;
    }
    
    // Find max length
    int maxLen = 0;
    for (int i = 0; i < n; i++) {
        int len = strlen(words[i]);
        if (len > maxLen) {
            maxLen = len;
        }
    }
    
    // Precompute powers
    powers[0] = 1;
    for (int i = 1; i <= maxLen; i++) {
        powers[i] = (powers[i-1] * BASE) % MOD;
    }
    
    // Compute prefix and suffix hashes
    for (int idx = 0; idx < n; idx++) {
        int wordLen = strlen(words[idx]);
        
        // Prefix hashes
        prefixHashes[idx][0] = 0;
        for (int i = 0; i < wordLen; i++) {
            prefixHashes[idx][i+1] = (prefixHashes[idx][i] * BASE + words[idx][i]) % MOD;
        }
        
        // Suffix hashes
        suffixHashes[idx][0] = 0;
        for (int i = wordLen - 1; i >= 0; i--) {
            suffixHashes[idx][wordLen - i] = (suffixHashes[idx][wordLen - i - 1] * BASE + words[idx][i]) % MOD;
        }
    }
    
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int word1Len = strlen(words[i]);
            int word2Len = strlen(words[j]);
            
            if (word1Len > word2Len) {
                continue;
            }
            
            // Check if hash matches for prefix and suffix
            long long word1Hash = prefixHashes[i][word1Len];
            long long prefixHashJ = prefixHashes[j][word1Len];
            long long suffixHashJ = suffixHashes[j][word1Len];
            
            if (word1Hash == prefixHashJ && word1Hash == suffixHashJ) {
                // Verify to avoid hash collisions
                if (strncmp(words[j], words[i], word1Len) == 0 && 
                    strcmp(words[j] + word2Len - word1Len, words[i]) == 0) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char *p = line;
    
    // Skip to first quote
    while (*p && *p != '"') p++;
    
    while (*p) {
        if (*p == '"') {
            p++; // Skip opening quote
            int len = 0;
            while (*p && *p != '"') {
                words[n][len++] = *p++;
            }
            words[n][len] = '\0';
            n++;
            if (*p == '"') p++; // Skip closing quote
        } else {
            p++;
        }
    }
    
    int result = solution(n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

Nested loops over n strings, each string comparison takes O(m) time where m is average string length

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

2.5K Views

Medium Frequency

~35 min Avg. Time

89 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