Word Break - Practice Coding Problems

Word Break - Problem

Array Hash Table String Dynamic Programming Trie Memoization Medium

Word Break is a classic dynamic programming problem that tests your ability to decompose strings efficiently.

You're given a string s and a dictionary of words wordDict. Your task is to determine if the entire string can be segmented into a sequence of dictionary words, where each word is separated by spaces.

Key Points:
• Words from the dictionary can be reused multiple times
• The entire string must be segmented (no leftover characters)
• Return true if segmentation is possible, false otherwise

Example: If s = "leetcode" and wordDict = ["leet", "code"], return true because "leetcode" can be segmented as "leet code".

Input & Output

example_1.py — 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.py — Word Reuse

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

› Output: true

💡 Note: The string can be segmented as "apple pen apple". Note that "apple" is reused from the dictionary.

example_3.py — Impossible Segmentation

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

› Output: false

💡 Note: No valid segmentation exists. While "cats", "and", "dog" are all in the dictionary, there's no way to segment "catsandog" completely.

Visualization

Tap to expand

Understanding the Visualization

Setup

Convert dictionary to hash set and initialize DP array

Check Each Position

For each position, look back at all previous valid positions

Validate Substring

Check if substring from valid position to current forms a dictionary word

Mark Valid

If valid word found, mark current position as reachable

Key Takeaway

🎯 Key Insight: Use dynamic programming to avoid recomputing the same subproblems - if you can segment up to position i, you can extend to position j if there's a valid word from i to j.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every substring of s, and for each position we might check up to n previous positions

⚠ Quadratic Growth

Space Complexity

O(n + m)

DP array of size n+1 plus hash set of size m (number of words in dictionary)

⚡ Linearithmic Space

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

Asked in

f Meta 45 a Amazon 38 G Google 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses Dynamic Programming with Hash Set to achieve O(n²) time complexity. Convert the dictionary to a hash set for O(1) word lookups, then build a DP array where dp[i] represents whether the substring s[0:i] can be segmented. The key insight is that if we can segment up to position j and there's a valid word from j to i, then we can segment up to position i.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Hash Set (Optimal)	O(n²)	O(n + m)	Use DP to build up valid positions and hash set for fast word lookup
Recursive Brute Force	O(2^n)	O(n)	Try all possible ways to split the string recursively

Dynamic Programming with Hash Set (Optimal) — Algorithm Steps

Convert wordDict to hash set for fast lookup
Create DP array where dp[i] means s[0:i] can be segmented
Initialize dp[0] = true (empty string is always valid)
For each position i, check all possible words ending at i
If dp[j] is true and s[j:i] is in wordDict, set dp[i] = true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0] = true, rest false

Check Position

For each position i, check all j < i

Validate

If dp[j] is true and s[j:i] is valid word, set dp[i] = true

Continue

Move to next position until end

Code -

solution.c — C

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

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

bool wordBreak(char* s, char** wordDict, int wordDictSize) {
    int n = strlen(s);
    bool* dp = (bool*)calloc(n + 1, sizeof(bool));
    dp[0] = true;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < i; j++) {
            if (dp[j]) {
                char* substr = (char*)malloc((i - j + 1) * sizeof(char));
                strncpy(substr, s + j, i - j);
                substr[i - j] = '\0';
                
                if (isInDict(substr, wordDict, wordDictSize)) {
                    dp[i] = true;
                    free(substr);
                    break;
                }
                free(substr);
            }
        }
    }
    
    bool result = dp[n];
    free(dp);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every substring of s, and for each position we might check up to n previous positions

⚠ Quadratic Growth

Space Complexity

O(n + m)

DP array of size n+1 plus hash set of size m (number of words in dictionary)

⚡ Linearithmic Space

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

52.5K Views

High Frequency

~18 min Avg. Time

1.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

Dynamic Programming with Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler