648. Replace Words

In English, we have a concept called root, which can be followed by some other words to form another longer word - let's call this word successor. For example, the root an, followed by other, which can form another word another.

Now, given a dictionary consisting of many roots and a sentence. You need to replace all the successor in the sentence with the rootforming it. If a successor has many roots can form it, replace it with the root with the shortest length.

You need to output the sentence after the replacement.

Example 1:

Input: dict = ["cat", "bat", "rat"]
sentence = "the cattle was rattled by the battery"
Output: "the cat was rat by the bat"

Note:

1. The input will only have lower-case letters.
2. 1 <= dict words number <= 1000
3. 1 <= sentence words number <= 1000
4. 1 <= root length <= 100
5. 1 <= sentence words length <= 1000

Trie树，没什么说的

package l648;

import java.util.List;

public class Solution {
	
	class Trie {
		boolean end = false;
		Trie[] next = new Trie[26];
	}
	
    public String replaceWords(List<String> dict, String sentence) {
    	Trie root = new Trie();
        for(String s : dict) {
        	buildTrie(root, s);
        }
        
        String[] ss = sentence.split(" ");
        StringBuilder sb = new StringBuilder();
        for(String s : ss) {
        	StringBuilder t = new StringBuilder();
        	findPrefix(root, s, t);
        	sb.append(t).append(" ");
        }
        
        return sb.toString().trim();
    }

	private void findPrefix(Trie root, String s, StringBuilder sb) {
		if(root.end)	return ;
		if("".equals(s))	return;
		char c = s.charAt(0);
		if(root.next[c-'a'] != null) {
			sb.append(c);
			findPrefix(root.next[c-'a'], s.substring(1), sb);
		} else {
			sb.append(s);
			return;
		}
	}

	private void buildTrie(Trie root, String s) {
		if("".equals(s)) {
			root.end = true;
			return;
		}
		char c = s.charAt(0);
		if(root.next[c-'a'] == null)
			root.next[c-'a'] = new Trie();
		buildTrie(root.next[c-'a'], s.substring(1));
	}
}

import collections
Trie = lambda: collections.defaultdict(Trie)

class Solution:
    def replaceWords(self, words, sentence):
        """
        :type dict: List[str]
        :type sentence: str
        :rtype: str
        """
        root = Trie()
        END = True
        
        for word in words:
            cur = root
            for c in word:
                cur = cur[c]
            cur[END] = word
        
        def replace(word):
            cur = root
            for c in word:
                if c not in cur: break
                cur = cur[c]
                if END in cur:  return cur[END]
            return word
        
        return ' '.join(list(map(replace, sentence.split(' '))))

s=Solution()
print("the cattle was rattled by the battery".split(' '))
print(s.replaceWords(["cat", "bat", "rat"], "the cattle was rattled by the battery"))

或者把string hash一下

def replaceWords(self, roots, sentence):
    rootset = set(roots)

    def replace(word):
        for i in xrange(1, len(word)):
            if word[:i] in rootset:
                return word[:i]
        return word

    return " ".join(map(replace, sentence.split()))