Word Break Problem using Backtracking
Last Updated :
25 Nov, 2024
Improve
Try it on GfG Practice 
Given a non-empty sequence s and a dictionary dict[] containing a list of non-empty words, the task is to return all possible ways to break the sentence in individual dictionary words.
Note: The same word in the dictionary may be reused multiple times while breaking.
Examples:
Input: s = “catsanddog” , dict = [“cat”, “cats”, “and”, “sand”, “dog”]
Output:
“cats and dog”
“cat sand dog”
Explanation: The string is split into above 2 ways, in each way all are valid dictionary words.
Input: s = “pineapplepenapple” , dict = [“apple”, “pen”, “applepen”, “pine”, “pineapple”]
Output:
“pine apple pen apple”
“pineapple pen apple”
“pine applepen apple”
Explanation: The string is split into above 3 ways, in each way all are valid dictionary words.
Approach:
For the recursive approach, there are two cases at each step (the size of the string decreases in each step):
- Include the current substring in the solution, If the substring exists in the dictionary, recursively check for the rest of the string starting from the next index.
- Skip the current substring and move to the next possible substring starting from the same index.
wordBreak(s,start) = wordBreak(s, end) , if s[start:end] ∈ dictionary
Base Case : wordBreak(s, start) = true, this signifies that a valid sentence has been constructed for the given input string.
Steps to implement the above idea:
- Convert the dictionary into a hash set for quick search.
- If the start index reaches the length of the string (s), it signifies a valid sentence has been constructed. Add the current sentence (curr) to the result.
- Loop through every substring starting at start and ending at all possible positions (end).
- For each substring, check if it exists in the dictionary (dictSet).
- If valid:
- Append the word to the current sentence (curr).
- Recursively call the function for the remaining part of the string (from end onwards).
- After the recursive call returns, restore the state of curr to ensure the next branch of exploration starts with the correct sentence.
// C++ implementation to find valid word
// break using Recursion
#include <bits/stdc++.h>
using namespace std;
// Helper function to perform backtracking
void wordBreakHelper(string& s, unordered_set<string>& dictSet,
string& curr, vector<string>& res,
int start) {
// If start reaches the end of the string,
// save the result
if (start == s.length()) {
res.push_back(curr);
return;
}
// Try every possible substring from the current index
for (int end = start + 1; end <= s.length(); ++end) {
string word = s.substr(start, end - start);
// Check if the word exists in the dictionary
if (dictSet.count(word)) {
string prev = curr;
// Append the word to the current sentence
if (!curr.empty()) {
curr += " ";
}
curr += word;
// Recurse for the remaining string
wordBreakHelper(s, dictSet, curr, res, end);
// Backtrack to restore the current sentence
curr = prev;
}
}
}
// Main function to generate all possible sentence breaks
vector<string> wordBreak(string s, vector<string>& dict) {
// Convert dictionary vector
// to an unordered set
unordered_set<string>
dictSet(dict.begin(), dict.end());
vector<string> res;
string curr;
wordBreakHelper(s, dictSet, curr, res, 0);
return res;
}
int main() {
string s = "ilikesamsungmobile";
vector<string> dict = {"i", "like", "sam", "sung",
"samsung", "mobile", "ice",
"and", "cream", "icecream",
"man", "go", "mango"};
vector<string> result = wordBreak(s, dict);
for (string sentence : result) {
cout << sentence << endl;
}
return 0;
}
// Java implementation to find valid
// word break using Recursion
import java.util.*;
class GfG {
// Helper function to perform backtracking
static void wordBreakHelper(String s, HashSet<String> dictSet,
String curr, List<String> res,
int start) {
// If start reaches the end of the string,
// save the result
if (start == s.length()) {
res.add(curr);
return;
}
// Try every possible substring from the current index
for (int end = start + 1; end <= s.length(); ++end) {
String word = s.substring(start, end);
// Check if the word exists in the dictionary
if (dictSet.contains(word)) {
String prev = curr;
// Append the word to the current sentence
if (!curr.isEmpty()) {
curr += " ";
}
curr += word;
// Recurse for the remaining string
wordBreakHelper(s, dictSet, curr, res, end);
// Backtrack to restore the current sentence
curr = prev;
}
}
}
// Main function to generate all possible sentence breaks
static List<String> wordBreak(String s, List<String> dict) {
// Convert dictionary vector to a HashSet
HashSet<String> dictSet = new HashSet<>(dict);
List<String> res = new ArrayList<>();
String curr = "";
wordBreakHelper(s, dictSet, curr, res, 0);
return res;
}
public static void main(String[] args) {
String s = "ilikesamsungmobile";
List<String> dict = Arrays.asList("i", "like", "sam", "sung",
"samsung", "mobile", "ice",
"and", "cream", "icecream",
"man", "go", "mango");
List<String> result = wordBreak(s, dict);
for (String sentence : result) {
System.out.println(sentence);
}
}
}
# Python implementation to find valid
# word break using Recursion
def wordBreakHelper(s, dictSet, curr, res, start):
# If start reaches the end of the string,
# save the result
if start == len(s):
res.append(curr)
return
# Try every possible substring from the current index
for end in range(start + 1, len(s) + 1):
word = s[start:end]
# Check if the word exists in the dictionary
if word in dictSet:
prev = curr
# Append the word to the current sentence
if curr:
curr += " "
curr += word
# Recurse for the remaining string
wordBreakHelper(s, dictSet, curr, res, end)
# Backtrack to restore the current sentence
curr = prev
def wordBreak(s, dict):
# Convert dictionary list to a set
dictSet = set(dict)
res = []
curr = ""
wordBreakHelper(s, dictSet, curr, res, 0)
return res
if __name__=='__main__':
s = "ilikesamsungmobile"
dict = ["i", "like", "sam", "sung",
"samsung", "mobile", "ice",
"and", "cream", "icecream",
"man", "go", "mango"]
result = wordBreak(s, dict)
for sentence in result:
print(sentence)
// C# implementation to find valid word
// break using Recursion
using System;
using System.Collections.Generic;
class GfG {
// Helper function to perform backtracking
static void wordBreakHelper(string s, HashSet<string> dictSet,
ref string curr, ref List<string> res,
int start) {
// If start reaches the end of the string,
// save the result
if (start == s.Length) {
res.Add(curr);
return;
}
// Try every possible substring from the current index
for (int end = start + 1; end <= s.Length; ++end) {
string word = s.Substring(start, end - start);
// Check if the word exists in the dictionary
if (dictSet.Contains(word)) {
string prev = curr;
// Append the word to the current sentence
if (curr.Length > 0) {
curr += " ";
}
curr += word;
// Recurse for the remaining string
wordBreakHelper(s, dictSet, ref curr,
ref res, end);
// Backtrack to restore the current sentence
curr = prev;
}
}
}
// Main function to generate all possible sentence breaks
static List<string> wordBreak(string s,
List<string> dict) {
// Convert dictionary list to a HashSet
HashSet<string> dictSet
= new HashSet<string>(dict);
List<string> res = new List<string>();
string curr = "";
wordBreakHelper(s, dictSet, ref curr, ref res, 0);
return res;
}
static void Main() {
string s = "ilikesamsungmobile";
List<string> dict
= new List<string> {"i", "like", "sam", "sung",
"samsung", "mobile", "ice",
"and", "cream", "icecream",
"man", "go", "mango"};
List<string> result = wordBreak(s, dict);
foreach (string sentence in result) {
Console.WriteLine(sentence);
}
}
}
// JavaScript implementation to find valid
// word break using Recursion
// Helper function to perform backtracking
function wordBreakHelper(s, dictSet, curr, res, start) {
// If start reaches the end of the string, save the result
if (start === s.length) {
res.push(curr);
return;
}
// Try every possible substring from the current index
for (let end = start + 1; end <= s.length; ++end) {
let word = s.substring(start, end);
// Check if the word exists in the dictionary
if (dictSet.has(word)) {
let prev = curr;
// Append the word to the current sentence
if (curr.length > 0) {
curr += " ";
}
curr += word;
// Recurse for the remaining string
wordBreakHelper(s, dictSet, curr, res, end);
// Backtrack to restore the current sentence
curr = prev;
}
}
}
// Main function to generate all possible sentence breaks
function wordBreak(s, dict) {
// Convert dictionary array to a Set
let dictSet = new Set(dict);
let res = [];
let curr = "";
wordBreakHelper(s, dictSet, curr, res, 0);
return res;
}
let s = "ilikesamsungmobile";
let dict = ["i", "like", "sam", "sung",
"samsung", "mobile", "ice",
"and", "cream", "icecream",
"man", "go", "mango"];
let result = wordBreak(s, dict);
result.forEach((sentence) => {
console.log(sentence);
});
Output
i like sam sung mobile i like samsung mobile
Time Complexity: O((2^n) * k), for a string of length n, there are 2^n possible partitions, and each substring check takes O(k) time (average substring length k), leading to O((2^n) * k).
Auxiliary Space: O(n), due to the recursion stack can go as deep as O(n) in the worst case.
