Word Break II

Word Break II - Problem

Array Hash Table String Dynamic Programming Backtracking Trie Memoization Hard

Given a string s and a dictionary of strings wordDict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences in any order.

Note that the same word in the dictionary may be reused multiple times in the segmentation.

Input & Output

Example 1 — Basic Segmentation

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

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

💡 Note: Two valid ways: 'cats' + 'and' + 'dog' = 'cats and dog', and 'cat' + 'sand' + 'dog' = 'cat sand dog'

Example 2 — No 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 combinations using different word splits

Example 3 — Single Word

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

› Output: []

💡 Note: No valid segmentation possible - 'andog' cannot be formed from dictionary words

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

F Facebook 85 G Google 72 a Amazon 65 M Microsoft 48

The key insight is to use backtracking/recursion to build all possible sentence combinations, with memoization to avoid recalculating the same subproblems. The memoization approach provides the best balance of correctness and efficiency. Time: O(2^n), Space: O(n × 2^n)

Common Approaches

✓ Backtracking with Early Pruning

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

Use backtracking to build sentences word by word. First check if remaining string can be broken into dictionary words (using Word Break I). If not possible, prune this branch early.

Brute Force Recursion

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

Recursively try every possible split point in the string. For each split, check if the left part is in dictionary, then recursively solve for the right part.

Memoization (Top-Down DP)

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

Same as brute force but store results for each starting position. When we encounter the same substring again, return cached result instead of recalculating.

Backtracking with Early Pruning — Algorithm Steps

Check if string can be broken (Word Break I)
If yes, try each valid first word
Recursively build remaining sentence
Backtrack if no valid continuation found

Visualization

Tap to expand

Step-by-Step Walkthrough

Check

Before exploring, check if remaining string can be segmented

Prune

If impossible, don't explore this branch - backtrack immediately

Continue

If possible, continue building solution recursively

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 1000
#define MAX_RESULTS 10000
#define MAX_SENTENCE_LEN 2000

char words[MAX_WORDS][MAX_LEN];
int wordCount = 0;
char results[MAX_RESULTS][MAX_SENTENCE_LEN];
int resultCount = 0;
char s[MAX_LEN];

bool isInDict(const char* word) {
    for (int i = 0; i < wordCount; i++) {
        if (strcmp(words[i], word) == 0) return true;
    }
    return false;
}

bool canBreak(const char* str) {
    int len = strlen(str);
    bool dp[len + 1];
    memset(dp, false, sizeof(dp));
    dp[0] = true;
    
    char temp[MAX_LEN];
    for (int i = 1; i <= len; i++) {
        for (int j = 0; j < i; j++) {
            strncpy(temp, str + j, i - j);
            temp[i - j] = '\0';
            if (dp[j] && isInDict(temp)) {
                dp[i] = true;
                break;
            }
        }
    }
    
    return dp[len];
}

void backtrack(int start, char currentWords[][MAX_LEN], int currentCount) {
    if (start == strlen(s)) {
        if (currentCount == 0) {
            strcpy(results[resultCount++], "");
        } else {
            char sentence[MAX_SENTENCE_LEN] = "";
            for (int i = 0; i < currentCount; i++) {
                if (i > 0) strcat(sentence, " ");
                strcat(sentence, currentWords[i]);
            }
            strcpy(results[resultCount++], sentence);
        }
        return;
    }
    
    // Early pruning - check if remaining can be broken
    if (!canBreak(s + start)) {
        return;
    }
    
    char temp[MAX_LEN];
    for (int end = start + 1; end <= strlen(s); end++) {
        strncpy(temp, s + start, end - start);
        temp[end - start] = '\0';
        
        if (isInDict(temp)) {
            strcpy(currentWords[currentCount], temp);
            backtrack(end, currentWords, currentCount + 1);
        }
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char line[MAX_LEN];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char* token = strtok(line + 1, ",");
    while (token != NULL) {
        while (*token == ' ' || *token == '"') token++;
        char* end = token + strlen(token) - 1;
        while (*end == ' ' || *end == '"' || *end == ']') end--;
        *(end + 1) = '\0';
        strcpy(words[wordCount++], token);
        token = strtok(NULL, ",");
    }
    
    char currentWords[MAX_LEN][MAX_LEN];
    backtrack(0, currentWords, 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(2^n)

Still need to generate all valid sentence combinations, but pruning reduces constant factors

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth is at most n (length of string), plus space for DP array in Word Break check

⚠ Quadratic Space

125.0K Views

High Frequency

~25 min Avg. Time

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

Backtracking with Early Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler