Word Break II - Practice Coding Problems

Word Break II - Problem

Array Hash Table String Dynamic Programming Backtracking Trie Memoization Hard

Word Break II: Sentence Reconstruction Challenge

Imagine you have a string of characters with no spaces and a dictionary of valid words. Your mission is to add spaces strategically to transform this string into meaningful sentences where every word exists in your dictionary.

🎯 Goal: Find all possible ways to break the string into valid dictionary words
📝 Input: A string s and an array wordDict of dictionary words
🎁 Output: All possible sentences formed by adding spaces

Example: Given s = "catsanddog" and wordDict = ["cat", "cats", "and", "sand", "dog"], you could form:
• "cats and dog"
• "cat sand dog"

Note: Dictionary words can be reused multiple times in different combinations!

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Both "cats and dog" and "cat sand dog" are valid sentences. "cats" + "and" + "dog" and "cat" + "sand" + "dog" are both valid word combinations.

example_2.py — Multiple Solutions

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

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

💡 Note: Three different ways to break the string: using "pine apple", "pineapple", or "pine applepen" at the beginning.

example_3.py — No Solution

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

› Output: []

💡 Note: No valid way to break "catsandog" using the given dictionary words. "sandog" is not breakable into valid words.

Visualization

Tap to expand

Understanding the Visualization

Setup

Convert dictionary to hash set for O(1) lookup. Initialize memoization cache.

Try First Word

At each position, try all possible words that start from current position.

Recursively Solve

For each valid word found, recursively solve for the remaining substring.

Cache Results

Store results for each starting position to avoid redundant calculations.

Combine Solutions

Combine current word with all solutions from remaining string to build final sentences.

Key Takeaway

🎯 Key Insight: Memoization transforms an exponential problem into a manageable one by caching substring solutions, making Word Break II efficient even with multiple valid combinations!

Time & Space Complexity

Time Complexity

⏱️

O(n² + 2^n)

O(n²) to check all substrings, plus O(2^n) for generating all possible combinations in worst case

⚠ Quadratic Growth

Space Complexity

O(n² + 2^n)

O(n²) for memoization table plus O(2^n) for storing all possible sentences

⚠ Quadratic Space

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 the strings of wordDict are unique
Input is guaranteed to be valid according to the problem's requirements

Asked in

G Google 67 a Amazon 45 f Facebook 38 ⊞ Microsoft 29 Apple 22

The optimal approach uses memoized backtracking to find all possible sentence reconstructions. By caching results for each substring position, we eliminate redundant calculations and achieve O(n² + 2^n) time complexity. The key insight is that the same substring can appear multiple times during recursion, so memoization provides dramatic performance improvements over naive backtracking.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(2^n)	O(n)	Try every possible way to split the string using recursive backtracking
Memoized Backtracking (Optimal)	O(n² + 2^n)	O(n² + 2^n)	Use memoization to cache results of subproblems, avoiding redundant calculations

Brute Force Backtracking — Algorithm Steps

Start from the beginning of the string
Try every possible first word (check all prefixes)
If prefix is valid, recursively solve for the remaining string
Combine current word with all solutions from remaining string
Backtrack and try the next possible prefix

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at beginning

Begin with empty sentence and full string

Try first word

Check if first few characters form a valid word

Recurse on remainder

If valid, solve recursively for remaining string

Combine results

Add current word to all solutions from remainder

Backtrack

Try next possible word length and repeat

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 100
#define MAX_RESULTS 1000

char results[MAX_RESULTS][MAX_LEN];
int result_count = 0;

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

void backtrack(char* s, char wordDict[][MAX_LEN], int dictSize, int start, char* current) {
    if (start == strlen(s)) {
        strcpy(results[result_count++], current);
        return;
    }
    
    for (int end = start + 1; end <= strlen(s); end++) {
        char word[MAX_LEN];
        strncpy(word, s + start, end - start);
        word[end - start] = '\0';
        
        if (isInDict(word, wordDict, dictSize)) {
            char newCurrent[MAX_LEN];
            if (strlen(current) == 0) {
                strcpy(newCurrent, word);
            } else {
                sprintf(newCurrent, "%s %s", current, word);
            }
            backtrack(s, wordDict, dictSize, end, newCurrent);
        }
    }
}

char** wordBreak(char* s, char wordDict[][MAX_LEN], int dictSize, int* returnSize) {
    result_count = 0;
    char current[MAX_LEN] = "";
    backtrack(s, wordDict, dictSize, 0, current);
    
    char** res = (char**)malloc(result_count * sizeof(char*));
    for (int i = 0; i < result_count; i++) {
        res[i] = (char*)malloc((strlen(results[i]) + 1) * sizeof(char));
        strcpy(res[i], results[i]);
    }
    *returnSize = result_count;
    return res;
}

int main() {
    char s[] = "catsanddog";
    char wordDict[][MAX_LEN] = {"cat", "cats", "and", "sand", "dog"};
    int dictSize = 5;
    int returnSize;
    char** result = wordBreak(s, wordDict, dictSize, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%s\n", result[i]);
        free(result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we try every possible way to split the string, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can go up to n levels deep

⚡ Linearithmic Space

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 the strings of wordDict are unique
Input is guaranteed to be valid according to the problem's requirements

95.4K Views

High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler