Longest Common Suffix Queries - Practice Coding Problems

Longest Common Suffix Queries - Problem

You have two collections of words: a container of strings and a list of query strings. For each query word, your mission is to find the word in the container that shares the longest common suffix with it.

But here's where it gets interesting - if multiple words tie for the longest suffix match, you need to pick the shortest one. And if there's still a tie? Choose the one that appeared earliest in the container.

Example: If your query is "running" and your container has ["sing", "ring", "walking"], both "sing" and "ring" share the suffix "ing" (3 characters), but "sing" is shorter, so it wins!

Return an array of indices pointing to the best match for each query.

Input & Output

example_1.py — Basic Suffix Matching

$ Input: wordsContainer = ["abcd", "bcd", "xbcd"] wordsQuery = ["cd"]

› Output: [1]

💡 Note: All three words end with "cd", but "bcd" is shortest (3 chars) so it wins. Query "cd" matches with container word at index 1.

example_2.py — Tie Breaking by Length

$ Input: wordsContainer = ["abcdefg", "ba", "cc", "dddd"] wordsQuery = ["string", "a"]

› Output: [1, 1]

💡 Note: For "string": no common suffixes, so choose shortest word "ba" (index 1). For "a": "ba" ends with "a", so index 1 is returned.

example_3.py — Multiple Queries

$ Input: wordsContainer = ["word", "sword", "world"] wordsQuery = ["ord", "ld", "orld"]

› Output: [0, 2, 2]

💡 Note: "ord": all words match "ord" suffix, "word" is shortest and earliest (index 0). "ld": only "world" matches (index 2). "orld": only "world" matches (index 2).

Constraints

1 ≤ wordsContainer.length, wordsQuery.length ≤ 10⁴
1 ≤ wordsContainer[i].length ≤ 5 × 10³
1 ≤ wordsQuery[i].length ≤ 5 × 10³
All strings consist of lowercase English letters only
Sum of wordsContainer[i].length ≤ 5 × 10⁵
Sum of wordsQuery[i].length ≤ 5 × 10⁵

Visualization

Tap to expand

Understanding the Visualization

Reverse Word Organization

Store all words backwards in a tree structure, like organizing phone numbers by their last digits

Track Best Matches

At each tree node, remember the shortest word that passes through it

Query Processing

For each query, walk the tree backwards to find the longest matching path

Retrieve Best Match

Return the stored best word from the deepest matching node

Key Takeaway

🎯 Key Insight: A suffix trie organized by word endings allows us to find the longest common suffix in O(M) time per query, rather than comparing against all N words each time.

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 5

The optimal solution uses a suffix trie data structure to efficiently find longest common suffixes. Build the trie by inserting all container words in reverse order, storing the best match info at each node. For queries, traverse the trie in reverse to find the deepest matching node and return its stored best word index.

Common Approaches

Approach	Time	Space	Notes
✓ Suffix Trie (Optimal)	O((N + Q) × M)	O(N × M)	Build a reverse trie of container words, then query for longest suffix matches
Brute Force (Compare All Pairs)	O(Q × N × M)	O(1)	Compare each query with every container word to find longest suffix match

Suffix Trie (Optimal) — Algorithm Steps

Create a trie node class with best word tracking
Insert all container words into trie in reverse order
For each insertion, update best word info at each node
For each query, traverse trie in reverse to find longest match
Return the stored best word index for the deepest match

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Suffix Trie

Insert each word in reverse order, tracking best match at each node

Store Best Info

At each trie node, store the shortest word (earliest index) that passes through

Query Traversal

For each query, traverse trie in reverse to find longest matching path

Return Best Match

Return the stored best word index from the deepest matching node

Code -

solution.c — C

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

#define ALPHABET_SIZE 26

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    int bestIndex;
    int bestLength;
} TrieNode;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        node->children[i] = NULL;
    }
    node->bestIndex = -1;
    node->bestLength = INT_MAX;
    return node;
}

int* stringIndices(char** wordsContainer, int containerSize, char** wordsQuery, int querySize, int* returnSize) {
    *returnSize = querySize;
    int* result = (int*)malloc(querySize * sizeof(int));
    
    TrieNode* root = createNode();
    
    // Build suffix trie
    for (int idx = 0; idx < containerSize; idx++) {
        char* word = wordsContainer[idx];
        int wordLen = strlen(word);
        TrieNode* node = root;
        
        // Update root
        if (wordLen < node->bestLength || node->bestIndex == -1) {
            node->bestIndex = idx;
            node->bestLength = wordLen;
        }
        
        // Insert word in reverse
        for (int i = wordLen - 1; i >= 0; i--) {
            int charIndex = word[i] - 'a';
            if (node->children[charIndex] == NULL) {
                node->children[charIndex] = createNode();
            }
            node = node->children[charIndex];
            
            // Update best word at this node
            if (wordLen < node->bestLength || node->bestIndex == -1) {
                node->bestIndex = idx;
                node->bestLength = wordLen;
            }
        }
    }
    
    // Process each query
    for (int q = 0; q < querySize; q++) {
        char* query = wordsQuery[q];
        int queryLen = strlen(query);
        TrieNode* node = root;
        int bestMatch = node->bestIndex;
        
        // Traverse trie in reverse
        for (int i = queryLen - 1; i >= 0; i--) {
            int charIndex = query[i] - 'a';
            if (node->children[charIndex] != NULL) {
                node = node->children[charIndex];
                bestMatch = node->bestIndex;
            } else {
                break;
            }
        }
        
        result[q] = bestMatch;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O((N + Q) × M)

N words to build trie + Q queries to search, each taking M time for string length

✓ Linear Growth

Space Complexity

O(N × M)

Trie can store up to N×M nodes in worst case (all different suffixes)

✓ Linear Space

26.0K Views

Medium Frequency

~35 min Avg. Time

847 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

Suffix Trie (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler