题解四十一

面试题12. 矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

示例 1：

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”
输出：true

示例 2：

输入：board = [[“a”,“b”],[“c”,“d”]], word = “abcd”
输出：false
（来源：力扣（LeetCode)）

思路：
对矩阵进行深度优先遍历，dfs 通过递归，先朝一个方向搜到底，再回溯至上个节点，沿另一个方向搜索，以此类推。
在搜索中，遇到这条路不可能和目标字符串匹配成功的情况，则应立即返回。
我们将遍历过的元素做标记，不能再次访问。
递归的终止条件：
（1） 行或列索引越界；
（2）当前矩阵元素与目标字符不同；
（3）当前矩阵元素已访问过。

例如示例1，目标字符串Word为“ABCCED”。从矩阵左上角开始遍历元素，dfs遍历方向为“上、下、左、右”。

A	B	C	E
S	F	C	S
A	D	E	E

此时A已经被遍历，与目标字符串的第一个字符“A”相同，接着匹配目标字符串的第二个字符“B”，矩阵再往下遍历有几种情况：
（1）如果向下遍历时，‘S’ ≠ ‘B’，与目标字符串不匹配，则返回false；
（2）如果向上遍历时，索引越界，则返回false；
（3）向右遍历时，‘B’ = ‘B’,则将’B’标记为已访问状态。

A	B	C	E
S	F	C	S
A	D	E	E

接着匹配目标字符串的第三个字符‘C’，从矩阵’B’往下遍历时：
（1）如果向下遍历时，‘F’ ≠ ‘B’，与目标字符串不匹配，则返回false；
（2）如果向上遍历时，索引越界，则返回false；
（3）向右遍历时，‘C’ = ‘C’,则将’C’标记为已访问状态。

A	B	C	E
S	F	C	S
A	D	E	E

接着匹配目标字符串的第四个字符‘C’，从矩阵’C’往下遍历时，与以上步骤相同，最后‘C’向下遍历时，才能匹配到目标字符串里的‘C’。

A	B	C	E
S	F	C	S
A	D	E	E

接着匹配目标字符串的第五个字符‘E’，与以上步骤相同，从‘C’向下遍历时，才能匹配到目标字符串里的“E”。

A	B	C	E
S	F	C	S
A	D	E	E

接着匹配目标字符串的第六个字符‘D’，从矩阵’E’往下遍历时：
（1）向下遍历时，索引越界，返回false；
（2）向上遍历时，‘E’上方的字符已经被访问过了，返回false；
（3）向右遍历时，访问到的字符‘E’ ≠ ‘D’，返回false；
（4）向左遍历时，访问到的字符‘D’ = ‘D’，将字符‘D’设置为已访问状态。

A	B	C	E
S	F	C	S
A	D	E	E

此时当前字符串的索引为word.length ，即字符串已经全部匹配完毕，返回true。

class Solution {
    public boolean exist(char[][] board, String word) {
        int m = board.length;
        int n = board[0].length;
        if (board == null || board[0] == null || m == 0 || n == 0 || word == null || word.equals("")) {
            return false;
        }
        boolean[][] marked = new boolean[m][n];
        char[] arr = word.toCharArray();

        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (board[i][j] == arr[0]) {
                    if (dfs(board, i, j, marked, arr, 0)) return true;
                }
            }
        }
        return false;
    }

    private boolean dfs(char[][] board, int i, int j, boolean[][] marked, char[] arr, int index) {

        if (index == arr.length) {
            return true;
        }
        if (i < 0 || j < 0 || i == board.length || j == board[0].length 
        || marked[i][j] || board[i][j] != arr[index]) {
            return false;
        }

        marked[i][j] = true;
        boolean res = dfs(board, i + 1, j, marked, arr, index + 1)
                || dfs(board, i - 1, j, marked, arr, index + 1)
                || dfs(board, i, j + 1, marked, arr, index + 1)
                || dfs(board, i, j - 1, marked, arr, index + 1);
        marked[i][j] = false;

        return res;
    }
}