Dictionary Word Segmentation - Problem

Given a string s and a dictionary of words wordDict, find all possible ways to segment the string into valid dictionary words.

Return a list of all possible segmentations where each segmentation is a space-separated string of dictionary words.

Example:

Input: s = "catsanddog", wordDict = ["cat","cats","and","sand","dog"]

Output: ["cats and dog", "cat sand dog"]

The string can be segmented as "cats and dog" or "cat sand dog".

Input & Output

Example 1 — Multiple Valid Segmentations

$ Input: s = "catsanddog", wordDict = ["cat","cats","and","sand","dog"]

› Output: ["cats and dog", "cat sand dog"]

💡 Note: Two valid ways: "cats" + "and" + "dog" or "cat" + "sand" + "dog". Both use only dictionary words.

Example 2 — Single Valid Segmentation

$ Input: s = "pineapplepenapple", wordDict = ["apple","pen","applepen","pine","pineapple"]

› Output: ["pine apple pen apple", "pineapple pen apple", "pine applepen apple"]

💡 Note: Multiple valid segmentations exist using different combinations of dictionary words.

Example 3 — No Valid Segmentation

$ Input: s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]

› Output: []

💡 Note: No way to segment the string using only dictionary words - 'andog' is not valid.

Constraints

1 ≤ s.length ≤ 20
1 ≤ wordDict.length ≤ 1000
1 ≤ wordDict[i].length ≤ 10
s and wordDict[i] consist of only lowercase English letters
All strings in wordDict are unique

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 42 M Microsoft 35

The key insight is to use dynamic programming with memoization to avoid recomputing segmentations for the same substring. The optimal approach combines recursion with caching, achieving O(n × 2^n) time complexity in worst case but performing much better on average inputs.

Common Approaches

✓ Dynamic Programming with Trie

⏱️ Time: O(n² × 2^n) Space: O(total chars + n × 2^n)

Build a trie from dictionary words for O(1) prefix checking, then use dynamic programming to find all valid segmentations efficiently.

Recursive Backtracking

⏱️ Time: O(2^n) Space: O(n)

For each position in the string, check if the prefix is a valid word. If yes, recursively solve for the remaining suffix and combine results.

Recursive with Memoization

⏱️ Time: O(n × 2^n) Space: O(n × 2^n)

Same recursive approach but store the results for each starting position to avoid recomputing the same substring segmentations multiple times.

Dynamic Programming with Trie — Algorithm Steps

Build trie from dictionary words
Use DP to check if segmentation exists
Reconstruct all valid segmentations
Optimize with early pruning

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Insert all dictionary words into trie

DP Bottom-Up

Fill DP table from end to start

Trie Traversal

Use trie for O(1) word validation

Combine Results

Merge valid prefixes with suffix solutions

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 1000
#define MAX_RESULTS 10000
#define ALPHABET_SIZE 26

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    int isWord;
} TrieNode;

char wordDict[MAX_WORDS][MAX_LEN];
int wordCount = 0;
char results[MAX_RESULTS][MAX_LEN];
int resultCount = 0;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

void insertWord(TrieNode* root, char* word) {
    TrieNode* curr = root;
    for (int i = 0; word[i]; i++) {
        int index = word[i] - 'a';
        if (!curr->children[index]) {
            curr->children[index] = createNode();
        }
        curr = curr->children[index];
    }
    curr->isWord = 1;
}

void dfs(char* s, int start, TrieNode* root, char* current, int len) {
    if (start == strlen(s)) {
        strcpy(results[resultCount++], current);
        return;
    }
    
    TrieNode* node = root;
    for (int end = start; end < strlen(s); end++) {
        int index = s[end] - 'a';
        if (!node->children[index]) {
            break;
        }
        node = node->children[index];
        
        if (node->isWord) {
            char word[MAX_LEN];
            strncpy(word, s + start, end - start + 1);
            word[end - start + 1] = '\0';
            
            char newCurrent[MAX_LEN];
            if (strlen(current) == 0) {
                strcpy(newCurrent, word);
            } else {
                sprintf(newCurrent, "%s %s", current, word);
            }
            
            dfs(s, end + 1, root, newCurrent, strlen(newCurrent));
        }
    }
}

int main() {
    char s[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char dictLine[MAX_LEN * 10];
    fgets(dictLine, sizeof(dictLine), stdin);
    dictLine[strcspn(dictLine, "\n")] = 0;
    
    char* token = strtok(dictLine + 1, ",]");
    while (token != NULL) {
        while (*token == ' ' || *token == '"') token++;
        char* end = token + strlen(token) - 1;
        while (end > token && (*end == ' ' || *end == '"')) end--;
        *(end + 1) = '\0';
        strcpy(wordDict[wordCount++], token);
        token = strtok(NULL, ",]");
    }
    
    TrieNode* root = createNode();
    for (int i = 0; i < wordCount; i++) {
        insertWord(root, wordDict[i]);
    }
    
    dfs(s, 0, root, "", 0);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", results[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2^n)

Building trie takes O(total chars), DP takes O(n²), reconstructing can generate 2^n segmentations

⚠ Quadratic Growth

Space Complexity

O(total chars + n × 2^n)

Trie storage plus DP table plus space for all valid segmentations

⚠ Quadratic Space

78.0K Views

High Frequency

~25 min Avg. Time

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

Dictionary Word Segmentation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Trie — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler