leetcode_79:单词搜索

这个题目就是典型的回溯法，然后我只会用一种比较耗时的回溯法，主要耗时或者耗费内存的地方在于对于访问标志数组的创建，因为每次走都是要新建一个访问标志数组的：

    public boolean exist(char[][] board, String word) {
        //boolean[][] visit = new boolean[board.length][board[0].length];
        for (int i = 0; i < board.length; ++i) {
            for (int j = 0; j < board[0].length; ++j) {
                boolean[][] visit = new boolean[board.length][board[0].length];
                if (visit(board, visit, word, 0, i, j)) { //以每个起点作为出发点去寻找
                    return true;
                }
            }
        }
        return false;
    }

    private boolean visit(char[][] board, boolean[][] visit, String word, int curPos, int x, int y) {
        if (curPos >= word.length()) //如果判断到字符串头了，则返回true
            return true;
        //如果判断超界了，则返回false
        if (x >= board.length || y >= board[0].length || x < 0 || y < 0)
            return false;
        //当前二维下标的元素和要判断的字符相等，则要从四个方向上去判断
        if (word.charAt(curPos) == board[x][y] && !visit[x][y]) {
            visit[x][y] = true; //设置当前点已经访问
            boolean[][][] array = new boolean[4][visit.length][visit[0].length];
            for(int i = 0; i < 4; ++i) {
                for(int j = 0;j < array[0].length; j++) {
                    array[i][j] = Arrays.copyOf(visit[j], array[i][j].length);
                }
            }
            //从4个方向上去访问
            return visit(board, array[0], word, curPos+1, x-1, y)
                    || visit(board, array[1], word, curPos+1, x+1, y)
                    || visit(board, array[2], word, curPos+1, x, y-1)
                    || visit(board, array[3], word, curPos+1, x, y+1);
        }
        //不相等直接返回false
        return false;
    }

---

优化的解法

看到了优化的解法只能说挺厉害的，像我的思路是每次去前进一步都要新建一个访问标志数组，不然在进行判断的时候就会乱掉。但其实我们全程只需要一个访问数组就可以了。主要是因为递归其实也是不停地在栈帧上去执行，执行完栈帧出栈，虽然上一个栈帧把访问的都改成了true，但如果最后没找到，我们只需要改回来就好了。

public class Solution {

    private boolean[][] marked;
    private int[][] direction = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
    // 盘面上有多少行
    private int m;
    // 盘面上有多少列
    private int n;
    private String word;
    private char[][] board;

    public boolean exist(char[][] board, String word) {
        m = board.length;
        if (m == 0) {
            return false;
        }
        n = board[0].length;
        marked = new boolean[m][n];
        this.word = word;
        this.board = board;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (dfs(i, j, 0)) {  //将每个位置作为七点来判断
                    return true;
                }
            }
        }
        return false;
    }

    private boolean dfs(int i, int j, int start) {
        if (start == word.length() - 1) {  //遍历到了最后一个字符，进行判断
            return board[i][j] == word.charAt(start);
        }
        if (board[i][j] == word.charAt(start)) {  //若当前字符满足，则去下一个方向找
            marked[i][j] = true;  //表示自己当前访问了这个点
            for (int k = 0; k < 4; k++) {  //继续向下走
                int newX = i + direction[k][0];
                int newY = j + direction[k][1];
                if (inArea(newX, newY) && !marked[newX][newY]) {
                    if (dfs(newX, newY, start + 1)) {
                        return true;  //如果找到了，则直接返回true；
                    }
                }
            }
            marked[i][j] = false;  //没找到，则返回去并擦除自己访问过的标志
        }
        return false;
    }

    private boolean inArea(int x, int y) {
        return x >= 0 && x < m && y >= 0 && y < n;
    }
}