Longest Word in Dictionary through Deleting

Longest Word in Dictionary through Deleting - Problem

Given a string s and a string array dictionary, return the longest string in the dictionary that can be formed by deleting some of the given string characters.

If there is more than one possible result, return the longest word with the smallest lexicographical order.

If there is no possible result, return the empty string.

Input & Output

Example 1 — Multiple Valid Words

$ Input: s = "wordgoodgoodgoodword", dictionary = ["word", "good", "goodword"]

› Output: "goodword"

💡 Note: All three words can be formed from s by deleting characters: 'word' (length 4), 'good' (length 4), 'goodword' (length 8). 'goodword' is longest.

Example 2 — Lexicographical Tie-Breaking

$ Input: s = "wordgoodgoodgoodword", dictionary = ["word", "good", "best"]

› Output: "good"

💡 Note: Both 'word' and 'good' have length 4 and can be formed as subsequences. Since they have equal length, we choose the lexicographically smaller one: 'good' < 'word', so return 'good'.

Example 3 — No Valid Words

$ Input: s = "wordgoodgoodgoodword", dictionary = ["xyz", "abc"]

› Output: ""

💡 Note: Neither 'xyz' nor 'abc' can be formed as subsequences of s, so return empty string.

Constraints

1 ≤ s.length ≤ 1000
1 ≤ dictionary.length ≤ 1000
1 ≤ dictionary[i].length ≤ 1000
s and dictionary[i] consist of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 Apple 15

The key insight is recognizing this as a subsequence matching problem. The optimal approach sorts the dictionary by length (descending) and lexicographically (ascending), then returns the first valid subsequence found. Time: O(n log n + n × m), Space: O(n).

Common Approaches

✓ Greedy

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

Brute Force - Check Every Word

⏱️ Time: O(n × m × k) Space: O(1)

For each word in dictionary, check if it can be formed by deleting characters from s. A word is valid if all its characters appear in s in the same order (subsequence).

Sort First - Optimize Lexicographical Order

⏱️ Time: O(n log n + n × m) Space: O(n)

Sort dictionary words first by length (descending) then by lexicographical order (ascending). This way, the first valid subsequence we find is guaranteed to be the answer.

Two Pointers - Efficient Subsequence Check

⏱️ Time: O(n × m) Space: O(1)

For each dictionary word, use two pointers - one for the word and one for string s. Move through s and advance word pointer when characters match. This efficiently determines if word is a subsequence.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    
    // Calculate row maximums (skyline from west/east)
    int* rowMax = (int*)calloc(n, sizeof(int));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > rowMax[i]) {
                rowMax[i] = grid[i][j];
            }
        }
    }
    
    // Calculate column maximums (skyline from north/south)
    int* colMax = (int*)calloc(n, sizeof(int));
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < n; i++) {
            if (grid[i][j] > colMax[j]) {
                colMax[j] = grid[i][j];
            }
        }
    }
    
    // Calculate total possible increase
    int totalIncrease = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // Max height without changing skyline
            int maxPossibleHeight = (rowMax[i] < colMax[j]) ? rowMax[i] : colMax[j];
            int increase = maxPossibleHeight - grid[i][j];
            totalIncrease += increase;
        }
    }
    
    free(rowMax);
    free(colMax);
    return totalIncrease;
}

int** parseGrid(const char* input, int* gridSize, int** gridColSize) {
    int len = strlen(input);
    if (len < 3) {
        *gridSize = 0;
        return NULL;
    }
    
    // Count rows
    int rows = 0;
    for (int i = 0; i < len; i++) {
        if (input[i] == '[' && i > 0) rows++;
    }
    
    if (rows == 0) {
        *gridSize = 0;
        return NULL;
    }
    
    int** grid = (int**)malloc(rows * sizeof(int*));
    *gridColSize = (int*)malloc(rows * sizeof(int));
    *gridSize = rows;
    
    int row = 0;
    int i = 1; // Skip first [
    
    while (i < len && row < rows) {
        if (input[i] == '[') {
            i++;
            // Count numbers in this row
            int nums = 1;
            int temp = i;
            while (temp < len && input[temp] != ']') {
                if (input[temp] == ',') nums++;
                temp++;
            }
            
            grid[row] = (int*)malloc(nums * sizeof(int));
            (*gridColSize)[row] = nums;
            
            // Parse numbers
            int col = 0;
            char numStr[20];
            int numIdx = 0;
            
            while (i < len && input[i] != ']' && col < nums) {
                if (isdigit(input[i]) || input[i] == '-') {
                    numStr[numIdx++] = input[i];
                } else if (input[i] == ',' || input[i] == ']') {
                    if (numIdx > 0) {
                        numStr[numIdx] = '\0';
                        grid[row][col++] = atoi(numStr);
                        numIdx = 0;
                    }
                }
                i++;
            }
            
            // Handle last number if no trailing comma
            if (numIdx > 0 && col < nums) {
                numStr[numIdx] = '\0';
                grid[row][col] = atoi(numStr);
            }
            
            row++;
        } else {
            i++;
        }
    }
    
    return grid;
}

int main() {
    char input[10000];
    if (fgets(input, sizeof(input), stdin) == NULL) {
        printf("0\n");
        return 0;
    }
    
    // Remove newline
    input[strcspn(input, "\n")] = '\0';
    
    int gridSize;
    int* gridColSize;
    int** grid = parseGrid(input, &gridSize, &gridColSize);
    
    if (grid == NULL || gridSize == 0) {
        printf("0\n");
        return 0;
    }
    
    printf("%d\n", solution(grid, gridSize, gridColSize));
    
    for (int i = 0; i < gridSize; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

58.2K Views

Medium Frequency

~25 min Avg. Time

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