79. 单词搜索【回溯】

79. 单词搜索

79. 单词搜索

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

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• m == board.length
• n = board[i].length
• 1 <= m, n <= 6
• 1 <= word.length <= 15
• board 和 word 仅由大小写英文字母组成

进阶：你可以使用搜索剪枝的技术来优化解决方案，使其在 board 更大的情况下可以更快解决问题？

解题思路

回溯+定义四个方向的技巧，能找到路径就是true，找不到就是false

Go代码

func exist(board [][]byte, word string) bool {
    if len(board) == 0 || len(board[0]) == 0 {
        return false
    }
    // 定义标记数组并初始化，标记当前位置是否遍历过
    isVisited := make([][]bool,len(board))
    for i := 0;i < len(isVisited);i++ {
        isVisited[i] = make([]bool,len(board[0]))
    }

    // 可以以任意一个格子作为出发点
    for i := 0;i < len(board);i++ {
        for j := 0;j < len(board[0]);j++ {
            // 以当前格子作为起点能找到一个符合条件的路径，就可以直接返回true了
            // 因为题目要求就是判断是否存在一条符合条件的路径即可
            if backtrack(board,word,i,j,0,isVisited) {
                return true
            }
        }
    }

    return false
}

// index 当前需要寻找word中的第几个字符了，path，当前
func backtrack(board [][]byte,word string,x,y,index int,isVisited [][]bool) bool {
    // 当前字符与目标字符不相等，返回false
    if board[x][y] != word[index] {
        return false
    }
    // 经过上面的判断后，说明当前字符与目标字符相等
    // 现在又判断是最后一个字符了，说明找到了一条符合条件的路径
    if index == len(word) - 1 {
        return true
    }
    isVisited[x][y] = true // 标记当前位置已经访问过
    // 上右下走四个方向
    dx := []int{-1,0,1,0}
    dy := []int{0,1,0,-1}

    for i := 0;i < 4;i++ {
        a := x + dx[i]
        b := y + dy[i]
        if a >= 0 && a < len(board) && b >= 0 && b < len(board[0]) && !isVisited[a][b] {
            // 朝当前方向走，能找到正确路径，找到后后续for的递归可以不用执行了，一直往上返回即可
            if backtrack(board,word,a,b,index + 1,isVisited) {
                return true
            }
        }
    }
    isVisited[x][y] = false // 回溯
    // 前面四个方向走都没有返回true，所以经过当前节点找不到正确路径，返回false
    return false
}

Java代码

主要看下注释，写的比较详细

class Solution {
    public boolean exist(char[][] board, String word) {
        /*思路：由于回溯法的递归特性，路径可以被看成是一个栈，当在矩阵中定位了路径中的前n个字符是位置之后，
        在与第n个字符对应的格子的周围都没有找到第n+1个字符，这时候只好在路上向上返回到第n-1个字符所在的运行栈，重新定位第n个字符*/
        
        if(board == null || board.length == 0) return false;
        //分别以矩阵中的每一个字符作为起点寻找
        for(int i = 0;i < board.length;i++)
            for(int j = 0;j < board[0].length;j++){
                if(dfs(board,word,0,i,j))
                    return true;
            }
        return false;
    }
    
    /*参数说明：board 矩阵  word 目标单词  n 当前是在查目标单词的第几个字符了  （x,y)矩阵中的第几个位置*/
    public boolean dfs(char[][] board,String word,int n,int x,int y){
        if(board[x][y] != word.charAt(n)) return false;//当前位置和我们需要的字符word.charAt(n)不同，该路径行不通
        if(n == word.length()-1) return true; //我们要查找的最后一个字符都通过了上面那条if语句，该单词路径存在
        //标记该单词走过了，在每次dfs的开始会判断if (matrix[x][y] != word.charAt(n)) return false;，
        //而'*'不会匹配给定单词里的任何一个字母，所以如果往下递归时 matrix[a][b] == ‘*’，就一定会返回false
         char temp = board[x][y];
         board[x][y] = '*';
        
        //需要递归的查找第n+1个字符了
        int[] dx = {-1,0,1,0};
        int[] dy = {0,-1,0,1};
        for(int i = 0;i < 4;i++){//分别尝试向左，上，右，下走
            int a = x+dx[i];
            int b = y + dy[i];
            if(a >=0 && a < board.length && b >= 0 && b < board[a].length){//保证board[a][b]还在矩阵范围内
                if(dfs(board,word,n+1,a,b))
                    return true;
            }
        }
        //当从第n个字符一直递归往下走的时候，一直没有返回true，即行不通，说明第n个字符选择走（x,y）位置行不通
        //从而需要回溯去尝试从n-1开始走的其他可以走的位置，而相对于n-1所在运行栈，当前的（x，y）就相当于没有走过了
        //比如，n-1位置选择另一方向走找到n,然后n又找到n+1,n+1又可以走此时的（x,y）位置了，如题目中假设n-1位置走的B，n位置走F,
        //但发现走F后，找不到目标word，则之后可以BCCF，即现在又可以走F了
        //所以应该把board[x][y]还原为temp
        board[x][y] = temp;
        return false;
    }  
}