Leetcode - Word Search

Given a 2D board and a word, find if the word exists in the grid.
The word can 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.

For example,
Given board =

[
  ["ABCE"],
  ["SFCS"],
  ["ADEE"]
]
word = "ABCCED", -> returns true,
word = "SEE", -> returns true,
word = "ABCB", -> returns false.

[分析] 思路是选定的元素开始，上下左右分别进行DFS搜索。在单次DFS搜索中，每个元素只能访问一次，因此DFS过程中需要对已访问的元素进行标记，一种方法是直接在board中修改，标记已访问元素为特殊字符，对其递归完成后恢复原值，另一种方法是使用一个m*n的辅助空间用于维护访问状态，后者代码更简洁。特别要注意：Method2 的DFS 方法中两个结束条件顺序不能调换，写成Wrong version那种在leetcode中会显示超时，事实上答案也有可能不对，考虑例子board=[["ab"]],word="ab", 就会wrong answer，如果board 每行内容很长，有很多行，word就是完整一行的内容，则就会导致超时。 递归时如果有多个结束条件，需要仔细辨别下它们的顺序。多谢yb君指点~

[ref]
http://blog.csdn.net/linhuanmars/article/details/24336987

public class Solution {
    //Method 2: 辅助数组标记是否被访问
    public boolean exist(char[][] board, String word) {
        if (board == null || board.length == 0 || board[0].length == 0 
            || word == null || word.length() == 0)
            return false;
        int rows = board.length;
        int cols = board[0].length;
        boolean[][] used = new boolean[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (dfs(board, word, 0, i, j, used))
                    return true;
            }
        }
        return false;
    }
    public boolean dfs(char[][] board, String word, int idx, int i, int j, boolean[][] used) {
        if (idx == word.length())
            return true;
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || used[i][j] || board[i][j] != word.charAt(idx))
            return false;
        used[i][j] = true;
        boolean result = dfs(board, word, idx + 1, i, j + 1, used)
                        || dfs(board, word, idx + 1, i, j - 1, used)
                        || dfs(board, word, idx + 1, i + 1, j, used)
                        || dfs(board, word, idx + 1, i - 1, j, used);
        used[i][j] = false;
        return result;
    }
 
    // Wrong version
    private boolean dfs(char[][] board, int i, int j, String word, int curr, boolean[][] used) {
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || used[i][j])
            return false;
        if (curr == word.length())
            return true;
        if (board[i][j] == word.charAt(curr)) {
            used[i][j] = true;
            boolean ret = dfs(board, i, j + 1, word, curr + 1, used)
                            || dfs(board, i, j - 1, word, curr + 1, used)
                            || dfs(board, i + 1, j, word, curr + 1, used)
                            || dfs(board, i - 1, j, word, curr + 1, used);
            used[i][j] = false;
            return ret;
        } else {
            return false;
        }
    }

    // Method 1: 修改原数组元素标记是否被访问
    public boolean exist1(char[][] board, String word) {
        if (board == null || board.length == 0 || board[0].length == 0 
            || word == null || word.length() == 0)
            return false;
        int rows = board.length;
        int cols = board[0].length;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (board[i][j] == word.charAt(0) && recur(board, word, i, j, 1))
                    return true;
            }
        }
        return false;
    }
    public boolean recur(char[][] board, String word, int i, int j, int idx) {
        if (idx == word.length())
            return true;
        char curr = board[i][j];
        char next = word.charAt(idx);
        // up
        if (i > 0 && board[i - 1][j] == next) {
            board[i][j] = '#';
            if (recur(board, word, i - 1, j, idx + 1))
                return true;
            board[i][j] = curr;
        }
        // down
        if (i < board.length - 1 && board[i + 1][j] == next) {
            board[i][j] = '#';
            if (recur(board, word, i + 1, j, idx + 1))
                return true;
            board[i][j] = curr;
        }
        // right
        if (j < board[0].length - 1 && board[i][j + 1] == next) {
            board[i][j] = '#';
            if (recur(board, word, i, j + 1, idx + 1))
                return true;
            board[i][j] = curr;
        }
        // left
        if (j > 0 && board[i][j - 1] == next) {
            board[i][j] = '#';
            if (recur(board, word, i, j - 1, idx + 1))
                return true;
            board[i][j] = curr;
        }
           
        return false;
    }
}