Longest Word in Dictionary through Deleting

Longest Word in Dictionary through Deleting - Problem

Imagine you have a master string and a dictionary of words. Your goal is to find the longest word from the dictionary that can be formed by deleting some characters from the master string (while keeping the relative order of remaining characters).

For example, if your master string is "wordgoodgoodgoodbestword" and your dictionary contains ["word", "good", "best", "good"], you can form:

"word" by keeping characters at positions [0,1,2,3]
"good" by keeping characters at positions [4,5,6,7]
"best" by keeping characters at positions [17,18,19,20]

The longest word is "word", "good", and "best" (all length 4), but lexicographically, "best" comes first, so we return "best".

Key Rules:

Characters must maintain their relative order from the original string
If multiple words have the same length, return the lexicographically smallest one
If no word can be formed, return an empty string

Input & Output

example_1.py — Basic Example

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

› Output: "best"

💡 Note: All words "word", "good", and "best" can be formed by deleting characters. Among the longest words (length 4), "best" is lexicographically smallest.

example_2.py — Single Character

$ Input: s = "abcr", dictionary = ["a","aa","aaa","aaaa"]

› Output: "a"

💡 Note: Only "a" can be formed as a subsequence. "aa", "aaa", and "aaaa" cannot be formed because there's only one 'a' in the string.

example_3.py — Empty Result

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

› Output: ""

💡 Note: None of the dictionary words can be formed as subsequences of "abc", so we return an 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

Understanding the Visualization

Prepare the Excavation

Sort your dictionary of target words by priority (longest first, then alphabetically)

Begin Excavation

For each target word, use two careful pointers - one tracking your position in the inscription, one in the target word

Match Characters

When you find a matching character, advance both pointers. Otherwise, continue scanning the inscription

Discover the Treasure

When you successfully match all characters of a word, you've found your archaeological treasure!

Key Takeaway

🎯 Key Insight: By sorting the dictionary strategically and using two pointers for subsequence checking, we can find the optimal word efficiently while ensuring the first match we find is always the best possible answer.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses two pointers technique with sorting. First, sort the dictionary by word length (descending) and lexicographically (ascending). Then for each word, use two pointers to check if it's a valid subsequence in O(n) time. Return the first match found, which is guaranteed to be optimal due to our sorting strategy.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Sorting	O(m * log m + n * m)	O(1)	Sort dictionary by length and lexicographical order, then use two pointers to check subsequences
Brute Force (Check All Words)	O(n * m * k)	O(1)	Check every word in dictionary using nested loops to see if it's a valid subsequence

Two Pointers with Sorting — Algorithm Steps

Sort dictionary by length (descending) then lexicographically (ascending)
For each word in sorted dictionary:
Use two pointers: one for main string, one for current word
Advance both pointers when characters match, only main string pointer otherwise
If word pointer reaches end, word is valid subsequence - return it
If no word is found, return empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Dictionary

Sort words by length (desc) and lexicographically (asc)

Initialize Pointers

Set two pointers: i for word, j for main string

Compare Characters

If characters match, advance both pointers; otherwise advance j only

Check Completion

If i reaches end of word, we found a valid subsequence

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    char* str1 = *(char**)a;
    char* str2 = *(char**)b;
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    
    if (len1 != len2) {
        return len2 - len1; // Descending by length
    }
    return strcmp(str1, str2); // Ascending lexicographically
}

int isSubsequence(char* word, char* s) {
    int i = 0, j = 0;
    int wordLen = strlen(word);
    int sLen = strlen(s);
    
    while (i < wordLen && j < sLen) {
        if (word[i] == s[j]) {
            i++;
        }
        j++;
    }
    
    return i == wordLen;
}

char* findLongestWord(char* s, char** dictionary, int dictSize) {
    qsort(dictionary, dictSize, sizeof(char*), compare);
    
    for (int i = 0; i < dictSize; i++) {
        if (isSubsequence(dictionary[i], s)) {
            char* result = (char*)malloc(strlen(dictionary[i]) + 1);
            strcpy(result, dictionary[i]);
            return result;
        }
    }
    
    char* result = (char*)malloc(1);
    result[0] = '\0';
    return result;
}

int main() {
    // Input parsing and function call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * log m + n * m)

m*log m for sorting dictionary, n*m for checking each word as subsequence

⚡ Linearithmic

Space Complexity

O(1)

Constant extra space (sorting can be done in-place)

✓ Linear Space

24.7K Views

Medium Frequency

~18 min Avg. Time

892 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

Two Pointers with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler