212. Word Search II

一、题目

　　1、审题

　　

　　2、分析

　　　　给出一个二维字符矩阵 board，一个字符串数组 words。求出矩阵中连续的字符能组成的 words 中的单词，一个单词只能用同一个位置的字符一次。

二、解答

　　1、思路：

　　　　采用 Trie 字典树。

　　　　①、根据 words 创建 一个 Trie

　　　　②、遍历 board，以每个字符为起始字符，在 Trie 中以 DFS 查找是否存在此 word

class Solution {
    public List<String> findWords(char[][] board, String[] words) {
        List<String> result = new ArrayList<String>();
        // 1、构造查找字典
        TrieNode root = buildTrie(words);
        
        // 2、 从每一个字符开始 dfs 查找是否有存在的单词
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                dfs(board, i, j, root, result);
            }
        }
        
        return result;
    }

    private void dfs(char[][] board, int i, int j, TrieNode node,
            List<String> result) {
        char c = board[i][j];
        if(c == '#' || node.children[c - 'a'] == null)
            return;
        node = node.children[c - 'a'];
        if(node.word != null) {    // found one
            result.add(node.word);
            node.word = null;
        }
        
        board[i][j] = '#';
        if(i > 0)
            dfs(board, i - 1, j, node, result);
        if(j > 0)
            dfs(board, i, j - 1, node, result);
        if(i < board.length - 1)
            dfs(board, i + 1, j, node, result);
        if(j < board[0].length - 1)
            dfs(board, i, j + 1, node, result);
        board[i][j] = c;
    }

    private TrieNode buildTrie(String[] words) {
        TrieNode root = new TrieNode();
        for(String word: words) {
            TrieNode node = root;
            for(char c: word.toCharArray()) {
                int i = c - 'a';
                if(node.children[i] == null)
                    node.children[i] = new TrieNode();
                node = node.children[i];
            }
            node.word = word;
        }
        return  root;
    }
}

class TrieNode {
    public boolean isWord;
    public TrieNode[] children = new TrieNode[26];
    public String word;

}

　　2、方法二，不使用字典树。采用一个 Boolean 数组记录当前位置是否访问过。

    public List<String> findWords(char[][] board, String[] words) {
        
        int rows = board.length;
        int cols = board[0].length;
        List<String> result = new ArrayList<String>();
        boolean[][] IS_USED = new boolean[rows][cols];

        for(String word: words) {
            for (int row = 0; row < rows; row++) {
                for (int col = 0; col < cols; col++) {
                    char[] cArray = word.toCharArray();
                    if(is_pattered(board, row, col, rows, cols, IS_USED, 0, word.length() - 1, cArray)) 
                        result.add(word);
                }
            }
        }
        
        return new ArrayList<String>(new HashSet<String>(result));
    }

    private boolean is_pattered(char[][] board, int row, int col, int rows, int cols, boolean[][] iS_USED, int start, int end, char[] cArray) {
        
        if(start > end)
            return true;
        
        if(row >= rows || col >= cols || row < 0 || col < 0)
            return false;
        
        if(board[row][col] != cArray[start] || iS_USED[row][col] == true)
            return false;
        
        iS_USED[row][col] = true;
        
        if(is_pattered(board, row + 1, col, rows, cols, iS_USED, start + 1, end, cArray) ||
                is_pattered(board, row - 1, col, rows, cols, iS_USED, start + 1, end, cArray) ||
                is_pattered(board, row, col + 1, rows, cols, iS_USED, start + 1, end, cArray) ||
                is_pattered(board, row, col - 1, rows, cols, iS_USED, start + 1, end, cArray)
        ) {
            iS_USED[row][col] = false;    // 恢复
            return true;
        }
        
        iS_USED[row][col] = false;
        
        return false;
    }