Leetcode 140. Word Break II

Problem

Given a string s and a dictionary of strings wordDict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences in any order.

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

Algorithm

Trie and dfs.
First, save the word in a tire. Then use the dfs to search in the string.

Code

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:
        # trie define
        class Trie:
            def __init__(self):
                self.root = {}
                
            def insert(self, word):
                cNode = self.root
                for c in word:
                    if not c in cNode:
                        cNode[c] = {}
                    cNode = cNode[c]
                if not 'leaf' in cNode:
                    cNode['leaf'] = {}
            
            def search(self, word):
                cNode = self.root
                for c in word:
                    if not c in cNode:
                        return False
                    cNode = cNode[c]
                if not 'leaf' in cNode:
                    return False
                else:
                    return True 
                
            def output(self, root, depth):
                for c in root:
                    print(' ' * depth, c)
                    self.output(root[c], depth+1)
        
        trie = Trie()
        dlen = len(wordDict)
        for i in range(dlen):
            trie.insert(wordDict[i])
        
        slen = len(s)
        save = []
        ans  = []
        def dfs(L, R):
            if L >= R:
                buf = ""
                cnt = 0
                for ss in save:
                    if cnt:
                        buf = buf + " "
                    buf = buf + save[cnt]
                    cnt = cnt + 1
                ans.append(buf)
                return
            for k in range(L, R):
                if trie.search(s[L:k+1]):
                    save.append(s[L:k+1])
                    dfs(k+1, R)
                    save.pop()
        
        dfs(0, slen)
        return ans