Longest Common Prefix of K Strings After Removal

Longest Common Prefix of K Strings After Removal - Problem

You are given an array of strings words and an integer k. Your task is to analyze what happens when each string is temporarily removed from the array.

Goal: For each index i, find the length of the longest common prefix among any k strings from the remaining array (after removing the string at index i).

Key Points:

You must select exactly k strings from distinct indices
Find the longest prefix that is common to all k selected strings
If removing element i leaves fewer than k strings, return 0
Return an array where answer[i] represents the answer for removing the i-th element

Example: If words = ["abc", "abcd", "ab", "a"] and k = 2, after removing index 0 ("abc"), we have ["abcd", "ab", "a"]. The best pair might be "abcd" and "ab" with common prefix "ab" (length 2).

Input & Output

Basic Example

$ Input: words = ["abc", "abcd", "ab", "a"], k = 2

› Output: [2, 2, 1, 2]

💡 Note: Remove 'abc': remaining ['abcd','ab','a'], best pair 'abcd'+'ab' = prefix 'ab' (length 2). Remove 'abcd': remaining ['abc','ab','a'], best pair 'abc'+'ab' = prefix 'ab' (length 2). Remove 'ab': remaining ['abc','abcd','a'], best pair 'abc'+'abcd' = prefix 'a' (length 1). Remove 'a': remaining ['abc','abcd','ab'], best pair 'abc'+'abcd' = prefix 'abc' (length 2).

Insufficient Strings

$ Input: words = ["hello", "world"], k = 3

› Output: [0, 0]

💡 Note: After removing any element, we have only 1 string remaining, which is less than k=3. Therefore, answer is 0 for all indices.

No Common Prefix

$ Input: words = ["xyz", "abc", "def"], k = 2

› Output: [0, 0, 0]

💡 Note: No matter which element we remove, the remaining strings have no common prefixes. For example, removing 'xyz' leaves ['abc', 'def'] with no common prefix.

Visualization

Tap to expand

Understanding the Visualization

Remove Shelf

Take away one shelf of books (remove string at index i)

Build Prefix Tree

Organize remaining books by their catalog prefixes in a tree structure

Count Books

At each tree level, count how many books share that prefix

Find Deepest Level

Locate the deepest tree level that still has at least k books

Key Takeaway

🎯 Key Insight: A Trie naturally organizes strings by prefixes, allowing us to efficiently find the longest common prefix by traversing to the deepest level with sufficient string count.

Time & Space Complexity

Time Complexity

⏱️

O(n * m * |remaining|)

For each of n removals, build a Trie taking O(m * |remaining|) where m is average string length and |remaining| is number of remaining strings

✓ Linear Growth

Space Complexity

O(m * |remaining|)

Trie storage requires space proportional to total characters in all strings

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
1 ≤ k ≤ words.length
words[i] consists of lowercase English letters only
All strings in words are distinct

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a Trie (prefix tree) data structure. For each removal, build a Trie from remaining strings where each node counts how many strings pass through it. Then find the deepest level with at least k strings, representing the longest common prefix length. This is more efficient than checking all combinations of k strings.

Common Approaches

Approach	Time	Space	Notes
✓ Trie-Based Optimization	O(n * m * \|remaining\|)	O(m * \|remaining\|)	Use Trie data structure to efficiently find longest common prefixes
Brute Force (Check All Combinations)	O(n * C(n,k) * m * k)	O(n)	For each removal, check all combinations of k strings and find their longest common prefix

Trie-Based Optimization — Algorithm Steps

For each index i, create remaining array without element i
Build a Trie from all remaining strings
Traverse Trie depth-first, counting strings at each node
Find the deepest level where at least k strings converge
Return the depth of this level as the longest common prefix length

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Insert all remaining strings into a Trie structure

Count Paths

Each node tracks how many strings pass through it

Find Depth

Find deepest level with at least k strings

Return Length

The depth represents the longest common prefix length

Code -

solution.c — C

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

#define ALPHABET_SIZE 26

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

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

TrieNode* buildTrie(char** strings, int size) {
    TrieNode* root = createNode();
    for (int i = 0; i < size; i++) {
        TrieNode* node = root;
        for (int j = 0; strings[i][j]; j++) {
            int idx = strings[i][j] - 'a';
            if (!node->children[idx]) {
                node->children[idx] = createNode();
            }
            node = node->children[idx];
            node->count++;
        }
    }
    return root;
}

int dfs(TrieNode* node, int depth, int k) {
    if (node->count < k) {
        return depth > 0 ? depth - 1 : 0;
    }
    
    int maxDepth = depth;
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        if (node->children[i]) {
            int childDepth = dfs(node->children[i], depth + 1, k);
            if (childDepth > maxDepth) {
                maxDepth = childDepth;
            }
        }
    }
    
    return maxDepth;
}

void deleteTrie(TrieNode* node) {
    if (!node) return;
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        deleteTrie(node->children[i]);
    }
    free(node);
}

int* longestCommonPrefixAfterRemoval(char** words, int wordsSize, int k, int* returnSize) {
    *returnSize = wordsSize;
    int* result = (int*)malloc(wordsSize * sizeof(int));
    
    for (int i = 0; i < wordsSize; i++) {
        char** remaining = (char**)malloc((wordsSize-1) * sizeof(char*));
        int remainingSize = 0;
        
        for (int j = 0; j < wordsSize; j++) {
            if (j != i) {
                remaining[remainingSize++] = words[j];
            }
        }
        
        if (remainingSize < k) {
            result[i] = 0;
        } else {
            TrieNode* root = buildTrie(remaining, remainingSize);
            result[i] = dfs(root, 0, k);
            deleteTrie(root);
        }
        
        free(remaining);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * |remaining|)

For each of n removals, build a Trie taking O(m * |remaining|) where m is average string length and |remaining| is number of remaining strings

✓ Linear Growth

Space Complexity

O(m * |remaining|)

Trie storage requires space proportional to total characters in all strings

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
1 ≤ k ≤ words.length
words[i] consists of lowercase English letters only
All strings in words are distinct

22.2K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Trie-Based Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler