Leetcode: Word Search II

Given a 2D board and a list of words from the dictionary, find all words in the board.

Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.

For example,
Given words = ["oath","pea","eat","rain"] and board =

[
  ['o','a','a','n'],
  ['e','t','a','e'],
  ['i','h','k','r'],
  ['i','f','l','v']
]
Return ["eat","oath"].

如果跟Word Search做法一样，还按照DFS回溯的方法，逐个检查每个word是否在board里，显然效率是比较低的。我们可以利用Trie数据结构，也就是前缀树。然后dfs时，如果当前形成的单词不在Trie里，就没必要继续dfs下去了。如果当前字符串在trie里，就说明board可以形成这个word。

这道题很好的体现了Trie的优势：不用Trie, 我们就得把String[] words里面的word一个一个去board里做dfs（以每个点为起点做一次），很耗时。有了Trie，我们可以用Trie存着所有word，然后去board里做一次dfs（以每个点为起点做一次）

需要小心的几点，我犯了错误：

1. 有可能board里面有多份某一个word，dfs会把它们都找出来，但是result set只需要添加一次就好了

有人是这样做的：Set<String> res = new HashSet<String>();

return的时候： return new ArrayList<String>(res);

2. 第21行 string concatenation actually creates a new string, and have the reference cur refer to the new string. It does not change the original content, so no changes will cause to the original content after the recursion. We do not need to do string shrinking like this cur = cur.substring(0, cur.length()-1) at the end of the recursion;

To be specific: suppose String str = "ab" is the original content, we use str to be the argument to call function dfs. In dfs function, String cur gets the reference to original object "ab". Now both String str and String cur refers to the original "ab". Now we do: cur = cur + 'a'. The '+' actually creates a deep copy of "ab" in the memory with the content "aba", an entirely new String object. And we assign reference cur to this new String object. Whatever changes we do to the new string object referred by cur, it does not influence the original string object str. So at the end of the dfs function, we either shrink or not shrink cur, it simply doesn't matter.

class Solution {
    public class TrieNode {
        TrieNode[] children;
        boolean isWord;
        public TrieNode() {
            this.children = new TrieNode[26];
            this.isWord = false;
        }
    }
    
    public class Trie {
        TrieNode root;
        
        public Trie() {
            this.root = new TrieNode();
        }
        
        public void insertWord(String word) {
            if (word == null || word.length() == 0) return;
            TrieNode cur = this.root;
            for (int i = 0; i < word.length(); i ++) {
                if (cur.children[word.charAt(i) - 'a'] == null) {
                    cur.children[word.charAt(i) - 'a'] = new TrieNode();
                }
                cur = cur.children[word.charAt(i) - 'a'];
            }
            cur.isWord = true;
        }
        
        public boolean search(String word) {
            TrieNode cur = this.root;
            for (int i = 0; i < word.length(); i ++) {
                if (cur.children[word.charAt(i) - 'a'] == null) return false;
                cur = cur.children[word.charAt(i) - 'a'];
            }
            return cur.isWord;
        }
        
        public boolean startsWith(String prefix) {
            TrieNode cur = this.root;
            for (int i = 0; i < prefix.length(); i ++) {
                if (cur.children[prefix.charAt(i) - 'a'] == null) return false;
                cur = cur.children[prefix.charAt(i) - 'a'];
            }
            return true;
        }
    }
    
    public List<String> findWords(char[][] board, String[] words) {
        List<String> res = new ArrayList<>();
        if (words == null || words.length == 0) return res;
        
        Trie tr = new Trie(); 
        for (String word : words) {
            tr.insertWord(word);
        }
        
        Set<String> set = new HashSet<>();
        for (int i = 0; i < board.length; i ++) {
            for (int j = 0; j < board[0].length; j ++) {
                dfs(board, i, j, "", tr, set);
            }
        }
        for (String item : set) {
            res.add(item);
        }
        return res;
    }
    
    public void dfs(char[][] board, int i, int j, String cur, Trie tr, Set<String> set) {
        if (tr.search(cur)) {
            set.add(cur);
        }
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] == '*') 
            return;
        if (!tr.startsWith(cur)) return;
        char c = board[i][j];
        board[i][j] = '*';
        dfs(board, i - 1, j, cur + c, tr, set);
        dfs(board, i + 1, j, cur + c, tr, set);
        dfs(board, i, j - 1, cur + c, tr, set);
        dfs(board, i, j + 1, cur + c, tr, set);
        board[i][j] = c;
    }
}