Longest String Chain - Practice Coding Problems

Longest String Chain - Problem

Array Hash Table Two Pointers String Dynamic Programming Sorting Medium

You are given an array of words where each word consists of lowercase English letters. Your task is to find the longest possible word chain that can be formed from these words.

What is a Word Chain?

A word chain is a sequence of words where each word is a predecessor of the next word. Word A is a predecessor of word B if and only if we can insert exactly one letter anywhere in word A (without changing the order of other characters) to make it equal to word B.

Examples of predecessors:

"abc" is a predecessor of "abxc" (insert 'x' at position 2)
"abc" is a predecessor of "xabc" (insert 'x' at position 0)
"cba" is NOT a predecessor of "bcad" (would require reordering)

Goal: Return the length of the longest possible word chain. A single word is trivially a word chain of length 1.

Input & Output

example_1.py — Basic Chain

$ Input: ["a","b","ba","bca","bda","bdca"]

› Output: 4

💡 Note: One of the longest word chains is ["a","ba","bda","bdca"] with length 4. Another valid chain is ["a","ba","bca","bdca"].

example_2.py — Multiple Chains

$ Input: ["xbc","pcxbcf","xb","cxbc","pcxbc"]

› Output: 5

💡 Note: The longest chain is ["xb","xbc","cxbc","pcxbc","pcxbcf"] with length 5.

example_3.py — Single Word

$ Input: ["abde","abc","abd","abcde","ade","ae","1abde","1abc","1abd","1abcde","1ade","1ae"]

› Output: 4

💡 Note: Multiple chains of length 4 exist, such as ["ae","ade","abde","abcde"].

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 16
words[i] only contains lowercase English letters
All strings are unique

Visualization

Tap to expand

Understanding the Visualization

Sort by Complexity

Arrange words by length - simpler forms must come before complex ones

Build Incrementally

For each word, check if removing any character gives us a known predecessor

Track Best Path

Remember the longest chain ending at each word using memoization

Find Maximum

Return the length of the longest chain found

Key Takeaway

🎯 Key Insight: By processing words in length order and using dynamic programming, we ensure that when we process a word of length n, all its potential predecessors of length n-1 have already been processed and their optimal chain lengths are known.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25

The optimal solution uses dynamic programming with memoization after sorting words by length. For each word, we try removing each character to find potential predecessors, then build chains incrementally. This achieves O(n × m²) time complexity where n is the number of words and m is the average word length.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n × m² + n log n)	O(n × m)	Sort by length and use DP to build chains incrementally with memoization
Brute Force DFS	O(n² × m)	O(n × m)	Try every possible chain starting from each word using DFS

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Sort words by length to ensure we process shorter words first
Create a hash map to store the longest chain ending at each word
For each word, try removing each character one by one
Check if the resulting shorter word exists in our processed words
If it exists, update current word's chain length as max of existing chains plus 1
Track the maximum chain length seen so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Length

Sort words: ['a', 'b', 'ba', 'bca', 'bdca']

Process 'a'

dp['a'] = 1 (base case)

Process 'ba'

Remove 'b' → 'a' exists, dp['ba'] = dp['a'] + 1 = 2

Process 'bca'

Remove 'c' → 'ba' exists, dp['bca'] = dp['ba'] + 1 = 3

Code -

solution.c — C

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

struct WordMap {
    char word[20];
    int length;
};

int compare(const void* a, const void* b) {
    return strlen(((char**)a)[0]) - strlen(((char**)b)[0]);
}

int findWord(char words[][20], int n, char* target) {
    for (int i = 0; i < n; i++) {
        if (strcmp(words[i], target) == 0) return i;
    }
    return -1;
}

int longestStrChain(char words[][20], int n) {
    // Simple sorting by length (bubble sort for simplicity)
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (strlen(words[j]) > strlen(words[j+1])) {
                char temp[20];
                strcpy(temp, words[j]);
                strcpy(words[j], words[j+1]);
                strcpy(words[j+1], temp);
            }
        }
    }
    
    int dp[n];
    for (int i = 0; i < n; i++) dp[i] = 1;
    
    int maxLength = 1;
    
    for (int i = 0; i < n; i++) {
        int currentMax = 1;
        int wordLen = strlen(words[i]);
        
        for (int j = 0; j < wordLen; j++) {
            char predecessor[20];
            strncpy(predecessor, words[i], j);
            strcpy(predecessor + j, words[i] + j + 1);
            
            int idx = findWord(words, i, predecessor);
            if (idx != -1) {
                if (dp[idx] + 1 > currentMax) {
                    currentMax = dp[idx] + 1;
                }
            }
        }
        
        dp[i] = currentMax;
        if (currentMax > maxLength) maxLength = currentMax;
    }
    
    return maxLength;
}

int main() {
    char words[][20] = {"a", "b", "ba", "bca", "bda", "bdca"};
    int n = 6;
    printf("%d\n", longestStrChain(words, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m² + n log n)

Sorting takes O(n log n), then for each word we try removing each of m characters and do hash lookup

⚡ Linearithmic

Space Complexity

O(n × m)

Hash map stores at most n entries, each word takes O(m) space

⚡ Linearithmic Space

67.2K Views

High Frequency

~25 min Avg. Time

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

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler