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"].

Note:
You may assume that all inputs are consist of lowercase letters a-z.

---

对比第７９题，７９题是判断一个字符串，而２１２题是判断多个字符串。思路和７９题类似，对矩阵里的每个元素做dfs，只不过７９题判断遍历到目前的substring是否在一个字符串里，而这题判断遍历到目前的substring是否在TrieTree里（相当于对所有字符串同时检查，而不是逐个检查）。

如果给的多个字符串有很多有相同的前缀，这个方法能降低时间复杂度。

public class Solution {
    public class TrieNode {
        int count;
        TrieNode[] children = new TrieNode[26];
        public void insert(String word) {
            TrieNode cur = this;
            int i = 0;
            while (i < word.length()) {
                if (cur.children[word.charAt(i) - ‘a‘] == null) {
                    cur.children[word.charAt(i) - ‘a‘] = new TrieNode();
                }
                cur = cur.children[word.charAt(i) - ‘a‘];
                i++;
            }
            cur.count = 1;
        }
        // 0: not prefix, 1: prefix, 2: contains string
        public int startsWith(String prefix) {
            TrieNode cur = this;
            int i = 0;
            while (i < prefix.length()) {
                if (cur.children[prefix.charAt(i) - ‘a‘] == null) {
                    return 0;
                }
                cur = cur.children[prefix.charAt(i) - ‘a‘];
                i++;
            }
            if (cur.count == 0) {
                return 1;
            } else {
                cur.count = 0;
                return 2;
            }
        }
    }
    TrieNode root = new TrieNode();
    public List<String> findWords(char[][] board, String[] words) {
        for (int i = 0; i < words.length; i++) {
            root.insert(words[i]);
        }
        boolean[][] visited = new boolean[board.length][board[0].length];
        List<String> re = new LinkedList<String>();
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                find(board, visited, i, j, "", re);
            }
        }
        return re;
    }
    public void find(char[][] board, boolean[][] visited, int i, int j, String str, List<String> list) {
        if (i < 0 || i > board.length - 1 || j < 0 || j > board[0].length - 1 || visited[i][j]) {
            return;
        }
        String tmp = str + board[i][j];
        int starts = root.startsWith(tmp);
        if (starts == 0) {
            return;
        } else {
            if (starts == 2) {
                list.add(tmp);
            }
            visited[i][j] = true;
            find(board, visited, i - 1, j, tmp, list);
            find(board, visited, i + 1, j, tmp, list);
            find(board, visited, i, j - 1, tmp, list);
            find(board, visited, i, j + 1, tmp, list);
            visited[i][j] = false;
        }
    }
}