Longest String Chain

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.

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 the other characters to make it equal to word B.

For example, "abc" is a predecessor of "abac", while "cba" is not a predecessor of "bcad".

A word chain is a sequence of words [word₁, word₂, ..., wordₖ] with k >= 1, where word₁ is a predecessor of word₂, word₂ is a predecessor of word₃, and so on. A single word is trivially a word chain with k == 1.

Return the length of the longest possible word chain with words chosen from the given list of words.

Input & Output

Example 1 — Basic Chain

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

› Output: 4

💡 Note: One longest chain is: "a" → "ba" → "bca" → "bdca". Each word is formed by adding exactly one character to the previous word while maintaining order.

Example 2 — Multiple Chains

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

› Output: 5

💡 Note: The longest chain is: "xb" → "xbc" → "cxbc" → "pcxbc" → "pcxbcf". Length is 5.

Example 3 — Single Word

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

› Output: 4

💡 Note: One longest chain is: "ae" → "ade" → "abde" → "abcde". Each step adds exactly one character.

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 16
words[i] only contains lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 F Facebook 28

The optimal approach is to sort words by length and use dynamic programming. For each word, check all shorter words to find valid predecessors. Time: O(n² × L), Space: O(n) where n is number of words and L is average word length.

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Brute Force - Try All Chains

⏱️ Time: O(n! × L) Space: O(n)

For each word, recursively try to extend the chain by checking all other words to see if they can be predecessors. This explores all possible combinations.

Dynamic Programming Bottom-Up

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

Sort words by length, then for each word, check all shorter words to see if they can be predecessors. Use DP to store the longest chain ending at each word.

Sort by Length + DFS

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

First sort all words by length since a predecessor must be shorter. Then use DFS to explore chains starting from each word, using memoization to avoid recomputing.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = (result * base) % mod;
        exp >>= 1;
        base = (base * base) % mod;
    }
    return result;
}

long long modInverse(long long a) {
    return modPow(a, MOD - 2, MOD);
}

long long comb(int n, int r) {
    if (r > n || r < 0) return 0;
    if (r == 0 || r == n) return 1;
    
    long long num = 1, den = 1;
    for (int i = 0; i < r; i++) {
        num = (num * (n - i)) % MOD;
        den = (den * (i + 1)) % MOD;
    }
    
    return (num * modInverse(den)) % MOD;
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int solution(int m, int n, int k) {
    if (k <= 1) return 0;
    
    long long total = 0;
    int totalCells = m * n;
    
    for (int i1 = 0; i1 < m; i1++) {
        for (int j1 = 0; j1 < n; j1++) {
            for (int i2 = 0; i2 < m; i2++) {
                for (int j2 = 0; j2 < n; j2++) {
                    if (i1 == i2 && j1 == j2) continue;
                    
                    int dist = abs_val(i1 - i2) + abs_val(j1 - j2);
                    
                    long long arrangements = comb(totalCells - 2, k - 2);
                    long long contribution = ((long long)dist * arrangements) % MOD;
                    total = (total + contribution) % MOD;
                }
            }
        }
    }
    
    total = (total * modInverse(2)) % MOD;
    return (int)total;
}

int main() {
    int m, n, k;
    scanf("%d", &m);
    scanf("%d", &n);
    scanf("%d", &k);
    
    printf("%d\n", solution(m, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

Medium-High Frequency

~25 min Avg. Time

2.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