Design Add and Search Words Data Structure

Design Add and Search Words Data Structure - Problem

Design a data structure that supports adding new words and finding if a string matches any previously added string.

Implement the WordDictionary class:

WordDictionary() - Initializes the object
void addWord(word) - Adds word to the data structure, it can be matched later
bool search(word) - Returns true if there is any string in the data structure that matches word or false otherwise. word may contain dots '.' where dots can be matched with any letter

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["WordDictionary","addWord","addWord","addWord","search","search","search","search"], parameters = [[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]

› Output: [null,null,null,null,false,true,true,true]

💡 Note: Initialize dictionary, add 'bad', 'dad', 'mad'. Search 'pad' (false), 'bad' (true), '.ad' matches 'bad', 'dad', 'mad' (true), 'b..' matches 'bad' (true)

Example 2 — Wildcard Pattern

$ Input: operations = ["WordDictionary","addWord","search","search"], parameters = [[],["a"],["."], ["a"]]

› Output: [null,null,true,true]

💡 Note: Add 'a', search '.' matches any single character including 'a' (true), search 'a' finds exact match (true)

Example 3 — No Match

$ Input: operations = ["WordDictionary","addWord","search"], parameters = [[],["abc"],["ab"]]

› Output: [null,null,false]

💡 Note: Add 'abc', search 'ab' has different length than stored word, no match (false)

Constraints

1 ≤ word.length ≤ 25
word in addWord consists of lowercase English letters
word in search consist of '.' or lowercase English letters
At most 10⁴ calls will be made to addWord and search

Visualization

Tap to expand

Asked in

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

The key insight is using a Trie data structure combined with recursive DFS for efficient wildcard pattern matching. The Trie enables fast prefix-based operations, while DFS handles wildcards by exploring all possible branches. Best approach uses Trie with DFS: Time: O(m) for add, O(26^k × m) for search with k wildcards, Space: O(ALPHABET_SIZE × N × M)

Common Approaches

✓ Brute Force with List

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

Store all added words in a simple list. For search operations, iterate through all stored words and check if each word matches the search pattern character by character, treating '.' as a wildcard.

Trie with DFS

⏱️ Time: O(m) for add, O(n×26^k) for search worst case Space: O(ALPHABET_SIZE×N×M)

Build a Trie (prefix tree) to store words efficiently. For search operations with wildcards, use depth-first search to explore all possible paths when encountering '.' characters.

Brute Force with List — Algorithm Steps

Store words in a list
For search, iterate through all stored words
Compare each word character by character with pattern

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Words

Store words in a simple list

Search Pattern

Check each stored word against search pattern

Character Match

Compare characters, treating '.' as wildcard

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 26
#define MAX_OPS 1000

typedef struct {
    char words[MAX_WORDS][MAX_WORD_LEN];
    int count;
} WordDictionary;

WordDictionary* wordDictionaryCreate() {
    WordDictionary* obj = (WordDictionary*)malloc(sizeof(WordDictionary));
    obj->count = 0;
    return obj;
}

void wordDictionaryAddWord(WordDictionary* obj, char* word) {
    strcpy(obj->words[obj->count], word);
    obj->count++;
}

bool wordDictionarySearch(WordDictionary* obj, char* word) {
    int wordLen = strlen(word);
    for (int i = 0; i < obj->count; i++) {
        if (strlen(obj->words[i]) == wordLen) {
            bool match = true;
            for (int j = 0; j < wordLen; j++) {
                if (word[j] != '.' && word[j] != obj->words[i][j]) {
                    match = false;
                    break;
                }
            }
            if (match) return true;
        }
    }
    return false;
}

static char operations[MAX_OPS][20];
static char parameters[MAX_OPS][30];

void parseInput() {
    char line1[1000], line2[2000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Parse operations - simplified parsing
    char* ptr = line1 + 1; // Skip [
    int opCount = 0;
    while (*ptr && *ptr != ']') {
        if (*ptr == '"') {
            ptr++;
            int i = 0;
            while (*ptr && *ptr != '"') {
                operations[opCount][i++] = *ptr++;
            }
            operations[opCount][i] = '\0';
            opCount++;
            if (*ptr == '"') ptr++;
        } else {
            ptr++;
        }
    }
    
    // Parse parameters - simplified
    ptr = line2 + 1; // Skip [
    int paramCount = 0;
    while (*ptr && *ptr != ']' && paramCount < MAX_OPS) {
        parameters[paramCount][0] = '\0'; // Default empty
        if (*ptr == '[') {
            ptr++;
            if (*ptr == '"') {
                ptr++;
                int i = 0;
                while (*ptr && *ptr != '"') {
                    parameters[paramCount][i++] = *ptr++;
                }
                parameters[paramCount][i] = '\0';
                if (*ptr == '"') ptr++;
            }
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
        }
        paramCount++;
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
    }
}

int main() {
    parseInput();
    
    WordDictionary* wd = wordDictionaryCreate();
    printf("[");
    
    int i = 0;
    while (i < MAX_OPS && strlen(operations[i]) > 0) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "WordDictionary") == 0) {
            printf("null");
        } else if (strcmp(operations[i], "addWord") == 0) {
            wordDictionaryAddWord(wd, parameters[i]);
            printf("null");
        } else if (strcmp(operations[i], "search") == 0) {
            bool result = wordDictionarySearch(wd, parameters[i]);
            printf("%s", result ? "true" : "false");
        }
        i++;
    }
    
    printf("]\n");
    free(wd);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Search requires checking all n words, each comparison takes O(m) time

✓ Linear Growth

Space Complexity

O(n×m)

Store all n words with average length m

⚡ Linearithmic Space

125.0K Views

High Frequency

~25 min Avg. Time

2.2K 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 with List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler