Word Break Problem ved hjælp af Backtracking

diktere[] indeholdende en liste over ikke-tomme ord, opgaven skal returnere alt muligt ordbogsord.
Det samme ord i ordbogen kan genbruges gange, mens den går i stykker.

knap i center css

Produktion:

Strengen er opdelt i ovenstående 2 måder på hver måde, alle er gyldige ordbogsord.

Input: s = ananaspenapple dict = [æblepen æblepen ananas]

pine apple pen æble

pinjeæble æble
Forklaring: Strengen er opdelt i ovenstående 3 måder på hver måde er alle gyldige ordbogsord.

Nærme sig:

ved hvert trin (størrelsen af strengen falder i hvert trin):

tjek for resten af strengen fra det næste indeks.
Springe de
wordBreak(sstart) = wordBreak(s end) if s[start:end] ∈ ordbog

Grundbogstav : wordBreak(s start) = sand dette betyder, at en gyldig sætning er blevet konstrueret for den givne inputstreng.

Trin til at implementere ovenstående idé:

Konverter ordbog for hurtig søgning.
Hvis startindeks gyldig sætning er blevet bygget. Tilføje
hver starter kl og
eksisterer i ordbogen
- Tilføj ordet til den aktuelle sætning (curr).
- Ring rekursivt af strengen (fra ende og frem).
gendanne curr

C++

// C++ implementation to find valid word // break using Recursion #include    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

// 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

# 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

// 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);  });

i like sam sung mobile i like samsung mobile

for en streng af længden n er der 2^n mulige partitioner, og hver delstrengkontrol tager O(k) tid (gennemsnitlig delstrenglængde k), hvilket fører til O((2^n) * k).
Hjælpeplads: O(n)