LeetCode 212. Word Search II

原题链接在这里：https://leetcode.com/problems/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"].

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

题解：

是Word Search的进阶版题目，同时可以利用Implement Trie (Prefix Tree).

生成Trie树，把所有的词都insert进去。

然后从board上的每一个char开始dfs查找。

终止条件有两个， 一个 i 和 j 出界，或者board[i][j]已经用过了. 另一个是把board[i][j]加到当前item后，若没有以更新过item为prefix的时候就可以返回了.

search 更新过的item, 若是有就加到res中, 并且继续，这里不能return, 因为有可能有 "aabc" "aabcb"两个词同时存在的情况，只检查了"aabc"就return会漏掉"aabcb".

标记当前used为true, 然后board四个方向都做recursion. used再改回来.

Note: 如果board 是[a a], words 只有一个[a], 此时小心重复加了，所以要用HashSet生成res, 最后再用res生成的List返回。

m = board.length, n = board[0].length, k = words.length, l 是 word的平均长度.

Time Complexity: O(k*l + m*n*l*4^l). k*l是简历Trie用时间. m*n是外部循环, l是search Trie时间, 4^l是recursion + backtracking的时间.

Space: O(k*l + l). k*l是Trie数的大小. 用了l层stack.

AC Java:

public class Solution {
    public List<String> findWords(char[][] board, String[] words) {
        HashSet<String> res = new HashSet<String>();
        if(words == null || words.length == 0 || board == null || board.length == 0 || board[0].length == 0){
            return new ArrayList(res);
        }
        Trie trie = new Trie();
        for(int i = 0; i<words.length; i++){
            trie.insert(words[i]);
        }
        
        boolean [][] used = new boolean[board.length][board[0].length];
        for(int i = 0; i<board.length; i++){
            for(int j = 0; j<board[0].length; j++){
                findHelper(board,trie,used,"",i,j,res);
            }
        }
        return new ArrayList(res);
    }
    private void findHelper(char[][] board, Trie trie, boolean [][] used, String item, int i, int j, HashSet<String> res){
        
        if(i<0 || j<0 || i>= board.length || j>=board[0].length || used[i][j]){
            return;
        }
        
        item = item+board[i][j];
        if(!trie.startsWith(item)){
            return;
        }
        if(trie.search(item)){
            res.add(item);
        }
        used[i][j] = true;
        findHelper(board,trie,used,item,i+1,j,res);
        findHelper(board,trie,used,item,i-1,j,res);
        findHelper(board,trie,used,item,i,j+1,res);
        findHelper(board,trie,used,item,i,j-1,res);
        used[i][j] = false;
    }
}


class TrieNode{
    String val = "";
    TrieNode [] nexts;
    public TrieNode(){
        nexts = new TrieNode[26];
    }
}
class Trie{
    private TrieNode root;
    public Trie(){
        root = new TrieNode();
    }
    
    public void insert(String word){
        TrieNode p = root;
        for(char c : word.toCharArray()){
            if(p.nexts[c-'a'] == null){
                p.nexts[c-'a'] = new TrieNode();
            }
            p = p.nexts[c-'a'];
        }
        p.val = word;
    }
    
    public boolean search(String word){
        TrieNode p = root;
        for(char c : word.toCharArray()){
            if(p.nexts[c-'a'] == null){
                return false;
            }
            p = p.nexts[c-'a'];
        }
        return p.val.equals(word);
    }
    
    public boolean startsWith(String prefix){
        TrieNode p = root;
        for(char c : prefix.toCharArray()){
            if(p.nexts[c-'a'] == null){
                return false;
            }
            p = p.nexts[c-'a'];
        }
        return true;
    }
}