Word Break

Word Break - Problem

Array Hash Table String Dynamic Programming Trie Memoization Medium

Given a string s and a dictionary of strings wordDict, return true if s can be segmented into a space-separated sequence of one or more dictionary words.

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

Input & Output

Example 1 — Basic Segmentation

$ Input: s = "leetcode", wordDict = ["leet","code"]

› Output: true

💡 Note: The string "leetcode" can be segmented as "leet code", where both "leet" and "code" are in the dictionary.

Example 2 — No Valid Segmentation

$ Input: s = "applepenapple", wordDict = ["apple","pen"]

› Output: true

💡 Note: The string "applepenapple" can be segmented as "apple pen apple", where "apple" and "pen" are both in the dictionary. Note that "apple" is reused.

Example 3 — Multiple Valid Paths

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

› Output: false

💡 Note: Even though "cats", "and", "dog" are all in dictionary, we cannot form "catsandog" because "sandog" cannot be segmented.

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 a Amazon 32 M Microsoft 28

The key insight is that this is a dynamic programming problem where we build the solution incrementally. For each position, we check if we can extend any previous valid segmentation with a dictionary word. The optimal approach uses 1D Dynamic Programming with Time: O(n³), Space: O(n).

Common Approaches

✓ Brute Force Recursion

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

For each position, try every possible word that could start there. If the word exists in dictionary, recursively check the remaining substring.

Dynamic Programming (Bottom-Up)

⏱️ Time: O(n³) Space: O(n)

Use a boolean array where dp[i] represents whether substring s[0:i] can be segmented. For each position, check all previous positions to see if we can extend a valid segmentation.

Memoization (Top-Down DP)

⏱️ Time: O(n³) Space: O(n)

Same as brute force but store results for each starting position to avoid redundant calculations. This dramatically reduces time complexity.

Brute Force Recursion — Algorithm Steps

Try each possible substring starting from current position
Check if substring exists in dictionary
If yes, recursively check remaining string
Return true if any path succeeds

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at position 0, try all possible first words

Recursive

For each valid word, recursively check remaining string

Result

Return true if any path reaches the end successfully

Code -

solution.c — C

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

bool canBreak(const char* s, int start, char wordDict[][20], int dictSize) {
    if (start == strlen(s)) {
        return true;
    }
    
    for (int end = start + 1; end <= strlen(s); end++) {
        char word[21];
        strncpy(word, s + start, end - start);
        word[end - start] = '\0';
        
        bool found = false;
        for (int i = 0; i < dictSize; i++) {
            if (strcmp(word, wordDict[i]) == 0) {
                found = true;
                break;
            }
        }
        
        if (found && canBreak(s, end, wordDict, dictSize)) {
            return true;
        }
    }
    return false;
}

bool solution(const char* s, char wordDict[][20], int dictSize) {
    return canBreak(s, 0, wordDict, dictSize);
}

int main() {
    char s[301];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char dictLine[1000];
    fgets(dictLine, sizeof(dictLine), stdin);
    dictLine[strcspn(dictLine, "\n")] = 0;
    
    char wordDict[100][20];
    int dictSize = 0;
    
    char* token = strtok(dictLine + 1, ",");
    while (token != NULL && dictSize < 100) {
        while (*token == ' ' || *token == '"') token++;
        int len = strlen(token);
        while (len > 0 && (token[len-1] == ' ' || token[len-1] == '"' || token[len-1] == ']')) {
            token[--len] = '\0';
        }
        if (len > 0) {
            strcpy(wordDict[dictSize++], token);
        }
        token = strtok(NULL, ",");
    }
    
    bool result = solution(s, wordDict, dictSize);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each position has 2 choices (break or continue), leading to exponential branches

✓ Linear Growth

Space Complexity

O(n)

Recursion depth can go up to length of string

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler