Find the String with LCP

Find the String with LCP - Problem

Array String Dynamic Programming Greedy Union Find Matrix Hard

We define the lcp matrix of any 0-indexed string word of n lowercase English letters as an n x n grid such that:

lcp[i][j] is equal to the length of the longest common prefix between the substrings word[i,n-1] and word[j,n-1].

Given an n x n matrix lcp, return the alphabetically smallest string word that corresponds to lcp. If there is no such string, return an empty string.

A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, string a has a letter that appears earlier in the alphabet than the corresponding letter in b.

Input & Output

Example 1 — Basic Case

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

› Output: abab

💡 Note: The LCP matrix corresponds to the string 'abab'. lcp[0][2] = 2 because substrings 'abab' and 'ab' share 'ab' as prefix.

Example 2 — Single Character

$ Input: lcp = [[1]]

› Output: a

💡 Note: For a single character, lcp[0][0] = 1 means the suffix has length 1, so the string is 'a'.

Example 3 — Impossible Case

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

› Output:

💡 Note: This matrix is impossible because lcp[0][1] = 3 but there are only 2 characters, so max LCP should be 2.

Constraints

1 ≤ lcp.length ≤ 1000
lcp[i].length == lcp.length
0 ≤ lcp[i][j] ≤ lcp.length

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use the LCP matrix constraints to build the string greedily, choosing the lexicographically smallest valid character at each position. The greedy approach ensures we get the smallest possible string while satisfying all LCP requirements. Time: O(n² × 26), Space: O(n²)

Common Approaches

✓ Frequency Count

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

Brute Force - Try All Strings

⏱️ Time: O(26ⁿ × n³) Space: O(n²)

Try every possible string of length n with lowercase letters, compute its LCP matrix, and return the lexicographically smallest one that matches the input matrix.

Greedy Character Construction

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

Use the LCP matrix constraints to determine what character can be placed at each position. At each step, try the smallest possible character ('a', 'b', etc.) that satisfies all LCP constraints.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_PATTERNS 1000

typedef struct {
    char pattern[100];
    int count;
} PatternCount;

int solution(int** matrix, int m, int n) {
    PatternCount patterns[MAX_PATTERNS];
    int numPatterns = 0;
    
    for (int i = 0; i < m; i++) {
        // Create pattern and complement strings
        char pattern[100] = "", complement[100] = "";
        
        for (int j = 0; j < n; j++) {
            char temp[10];
            sprintf(temp, "%d,", matrix[i][j]);
            strcat(pattern, temp);
            sprintf(temp, "%d,", 1 - matrix[i][j]);
            strcat(complement, temp);
        }
        
        // Use lexicographically smaller as canonical
        char* canonical = (strcmp(pattern, complement) < 0) ? pattern : complement;
        
        // Find existing pattern or add new one
        int found = 0;
        for (int k = 0; k < numPatterns; k++) {
            if (strcmp(patterns[k].pattern, canonical) == 0) {
                patterns[k].count++;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            strcpy(patterns[numPatterns].pattern, canonical);
            patterns[numPatterns].count = 1;
            numPatterns++;
        }
    }
    
    // Find maximum count
    int maxCount = 0;
    for (int i = 0; i < numPatterns; i++) {
        if (patterns[i].count > maxCount) {
            maxCount = patterns[i].count;
        }
    }
    
    return maxCount;
}

int parseMatrix(char* line, int*** matrix, int* m, int* n) {
    // Simple JSON-like parsing
    int rows = 0, cols = 0;
    
    // Count rows by counting '],' patterns
    char* temp = line;
    while (*temp) {
        if (*temp == '[' && (temp == line || *(temp-1) == ',')) rows++;
        temp++;
    }
    
    *matrix = (int**)malloc(rows * sizeof(int*));
    
    // Parse each row
    char* ptr = line + 1; // Skip first '['
    for (int i = 0; i < rows; i++) {
        // Skip to start of row
        while (*ptr == '[' || *ptr == ',') ptr++;
        
        // Count elements in this row
        char* rowStart = ptr;
        int colCount = 0;
        while (*ptr != ']') {
            if (*ptr == '0' || *ptr == '1') colCount++;
            ptr++;
        }
        
        if (i == 0) {
            cols = colCount;
            *n = cols;
        }
        
        (*matrix)[i] = (int*)malloc(cols * sizeof(int));
        
        // Parse the numbers
        ptr = rowStart;
        int j = 0;
        while (*ptr != ']' && j < cols) {
            if (*ptr == '0' || *ptr == '1') {
                (*matrix)[i][j] = *ptr - '0';
                j++;
            }
            ptr++;
        }
        ptr++; // Skip ']'
    }
    
    *m = rows;
    return 1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    int** matrix;
    int m, n;
    
    parseMatrix(line, &matrix, &m, &n);
    
    printf("%d\n", solution(matrix, m, n));
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

8.5K Views

Medium Frequency

~35 min Avg. Time

234 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