Find the String with LCP - Practice Coding Problems

Find the String with LCP - Problem

Array String Dynamic Programming Greedy Union Find Matrix Hard

Reverse Engineering Challenge: Reconstruct a String from its LCP Matrix

Imagine you're given a mysterious Longest Common Prefix (LCP) matrix and need to reverse-engineer the original string that created it. This is exactly what this problem asks you to do!

Given an n x n matrix lcp, where lcp[i][j] represents the length of the longest common prefix between suffixes starting at positions i and j, you must find the lexicographically smallest string that could have generated this matrix.

Key Points:
• The LCP matrix is derived from suffixes: word[i...] and word[j...]
• Return the alphabetically smallest valid string
• If no valid string exists, return an empty string

Example: If word = "aba", then:
• Suffixes: ["aba", "ba", "a"]
• lcp[0][1] = 1 ("aba" vs "ba" → common prefix "a")
• lcp[1][2] = 0 ("ba" vs "a" → no common prefix)

Input & Output

example_1.py — Simple Pattern

$ Input: lcp = [[4,0,2,0],[0,3,0,1],[2,0,2,0],[0,1,0,1]]

› Output: "abab"

💡 Note: The LCP matrix indicates that positions 0,2 must have the same character (lcp[0][2]=2) and positions 1,3 must have the same character (lcp[1][3]=1). The lexicographically smallest assignment is 'a' for positions 0,2 and 'b' for positions 1,3, giving us "abab".

example_2.py — All Same Characters

$ Input: lcp = [[2,1],[1,1]]

› Output: "aa"

💡 Note: Since lcp[0][1] = 1 > 0, positions 0 and 1 must have the same character. The lexicographically smallest choice is 'a', resulting in "aa". We can verify: lcp[0][0] = 2 ✓, lcp[1][1] = 1 ✓, lcp[0][1] = lcp[1][0] = 1 ✓

example_3.py — Invalid Matrix

$ Input: lcp = [[1,1],[1,1]]

› Output: ""

💡 Note: This matrix is invalid because lcp[0][0] should be 2 (length from position 0 to end), but it's given as 1. Since no valid string can produce this LCP matrix, we return an empty string.

Constraints

n == lcp.length == lcp[i].length
1 ≤ n ≤ 1000
0 ≤ lcp[i][j] ≤ n
The input matrix may not represent a valid LCP matrix
If multiple valid strings exist, return the lexicographically smallest one

Visualization

Tap to expand

Understanding the Visualization

Matrix Validation

Check if the LCP matrix follows required mathematical properties

Position Grouping

Use Union-Find to group positions that must have identical characters

Character Assignment

Assign lexicographically smallest characters to each group

Result Verification

Validate that our constructed string produces the input LCP matrix

Key Takeaway

🎯 Key Insight: LCP matrices encode character equality constraints - if two suffixes share a common prefix, their starting positions must have the same character. Union-Find efficiently groups these constraints, allowing us to build the lexicographically smallest valid string!

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses Union-Find to group positions that must have the same character based on LCP matrix properties. Key insights: positions i and j must have the same character if lcp[i][j] > 0, the matrix must be symmetric, and diagonal elements must equal n-i. We validate these properties, group positions, assign characters greedily starting with 'a', then verify the result produces the correct LCP matrix.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Validation	O(26^n × n³)	O(n²)	Generate all possible strings and check which ones produce the given LCP matrix
Greedy Construction with Validation	O(n³)	O(n²)	Build the string greedily using LCP matrix properties, then validate

Brute Force Validation — Algorithm Steps

Generate all possible strings of length n using 'a' to 'z'
For each string, compute its LCP matrix by comparing all suffix pairs
Check if the computed matrix matches the given matrix
Among all valid strings, return the lexicographically smallest one

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Candidates

Create all possible strings: 'aa...', 'ab...', etc.

Compute LCP

For each string, calculate its LCP matrix

Compare

Check if computed matrix matches input

Find Minimum

Return lexicographically smallest valid string

Code -

solution.c — C

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

int** computeLcpMatrix(char* word, int n) {
    int** matrix = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        matrix[i] = malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int k = 0;
            while (i + k < n && j + k < n && word[i + k] == word[j + k]) {
                k++;
            }
            matrix[i][j] = k;
        }
    }
    return matrix;
}

char* generateStrings(int pos, char* current, int** lcp, int n) {
    if (pos == n) {
        int** computed = computeLcpMatrix(current, n);
        // Compare matrices logic here
        return strdup(current);
    }
    
    for (char c = 'a'; c <= 'z'; c++) {
        current[pos] = c;
        current[pos + 1] = '\0';
        char* result = generateStrings(pos + 1, current, lcp, n);
        if (result) return result;
    }
    return NULL;
}

char* findTheString(int** lcp, int n) {
    char* current = malloc((n + 1) * sizeof(char));
    return generateStrings(0, current, lcp, n);
}

int main() {
    int n = 4;
    int** lcp = malloc(n * sizeof(int*));
    // Initialize lcp matrix
    printf("%s\n", findTheString(lcp, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^n × n³)

26^n possible strings, O(n²) to compute LCP matrix, O(n) to compare each pair of suffixes

⚠ Quadratic Growth

Space Complexity

O(n²)

Storage for the LCP matrix and string generation

⚠ Quadratic Space

43.4K Views

Medium-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

Brute Force Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler