一、题目描述

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

例如，在下面的 3×4 的矩阵中包含单词 "ABCCED"（单词中的字母已标出）。

示例 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

提示：

1 <= board.length <= 200

1 <= board[i].length <= 200

board 和 word 仅由大小写英文字母组成

二、思路讲解

对于我这种算法小白来说，看见在矩阵中东奔西走的题，第一反应就是深度优先搜索（dfs）。

首先我们可以暴力枚举矩阵中的每一个节点，分别对他们进行一次dfs，如果能够找到word就返回true，否则就去下一个节点。

那么问题就是如何编写dfs的代码：我们的思路是将这个节点（i，j）的上下左右相邻节点分别和word对应的字符比较，如果相同就继续往下搜索（找下一个节点的上下左右），如果不同就回溯到 （i，j）（剪枝操作），继续找其他方向；如果上下左右均不相同，说明（i，j）开头的地方不存在word。

然后需要考虑的问题是，如何避免走“回头路”？我们在这里可以先把（i，j）置为其他的值，这样在这次搜索中就不会再匹配到它了，在这次搜索结束后，我们再把它复原即可。

最后就是考虑dfs的边界问题了，如果指针超出了矩阵的范围，直接返回false

三、Java代码实现

class Solution {
    public boolean exist(char[][] board, String word) {
        //暴力枚举矩阵内的各个节点
    for(int i=0; i<board.length; i++) {
      for(int j=0; j<board[0].length; j++) {
        if(dfs(board, word, i, j, 0)) {
          return true;
        }
      }
    }
    return false;
    }
    public static boolean dfs(char[][] board, String word, int i, int j, int k) {
    int m = board.length-1;
    int n = board[0].length-1;
    //如果i或j已经超出边界，或者该位置的值和word的第一个字符不符，直接返回false
    if(i<0 || i>m || j<0 || j>n || board[i][j]!=word.charAt(k)) {
      return false;
    }
        //如果把word都遍历完了，说明合适
    if(k >= word.length()-1) {
      return true;
    }
    //先把这个位置置为其他字符，防止重复访问
    board[i][j] = '0';
    //向上下左右找（已经将原位置为空，不用担心又找回原位），找到就返回true
    boolean result = dfs(board, word, i-1, j, k+1) || dfs(board, word, i+1, j, k+1) ||
             dfs(board, word, i, j-1, k+1) || dfs(board, word, i, j+1, k+1);
    //把置空的位置恢复
    board[i][j] = word.charAt(k);
    return result;
  }
}

四、时空复杂度分析

时间复杂度：     O(3^KMN)        

最差情况下，需要遍历矩阵中长度为K字符串的所有方案，时间复杂度为 O(3^K)；矩阵中共有 MN个起点，时间复杂度为 O(MN) 。

方案数计算： 设字符串长度为 K，搜索中每个字符有上、下、左、右四个方向可以选择，舍弃回头（上个字符）的方向，剩下 3 种选择，因此方案数的复杂度为 O(3^K)

空间复杂度：      O(MN)

搜索过程中的递归深度不超过 K ，因此系统因函数调用累计使用的栈空间占用 O(K)（因为函数返回后，系统调用的栈空间会释放）。最坏情况下 K = MN ，递归深度为 MN ，此时系统栈使用 O(MN)的额外空间。