leetcode刷题(剑指offer) 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 仅由大小写英文字母组成

解法：

本题是经典的深搜+剪枝题，思路：从一个点，往上下左右四个方向进行搜索，如果能走，就递归走下去，当走完整个word的时候，表明数组中存在这个单词。

分析dfs的参数：board， 当前匹配的board中字符的横坐标， 当前匹配的board中字符的纵坐标，word, 当前word匹配的字符的wordIndex。

递归出口条件：当wordIndex(当前word匹配的字符所对应的索引)等于word的长度，即可返回匹配成功。或者当前wordIndex不能匹配borad的下一个，即可返回匹配失败。

注意点：走过的格子不能再走了，需要一个vis数组来判断当前格子有没有走过，如下：

代码实现如下：

package com.offer;


public class _79单词搜索 {

    private static boolean vis[][];

    public static void main(String[] args) {
        char[][] board = new char[][]{
                {'A', 'B', 'C', 'E'},
                {'S', 'F', 'C', 'S'},
                {'A', 'D', 'E', 'E'},
        };
        String word = "ABCCEDFSAD";
        System.out.println(exist(board, word));
    }

    public static boolean exist(char[][] board, String word) {
        vis = new boolean[board.length][board[0].length];
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                vis[i][j] = true;
                boolean ans = dfs(board, i, j, word, 0);
                vis[i][j] = false;
                if (ans) {
                    return true;
                }
            }
        }
        return false;
    }

    private static boolean dfs(char[][] board, int i, int j, String word, int wordIndex) {
        // 如果当前位置的值，不等于当前的单词匹配值，直接否定这条路
        if (board[i][j] != word.charAt(wordIndex)) return false;
        // 如果当前已经是最后一个值，且匹配正确，就直接返回true
        if (wordIndex == word.length() - 1) return true;
        for (int row = -1; row <= 1; row++) {
            for (int col = -1; col <= 1; col++) {
                if (row + col == 0 || Math.abs(row + col) == 2) continue;
                int r = i + row;
                int c = j + col;
                if (inBoard(board, r, c) && board[r][c] == word.charAt(wordIndex + 1) && !vis[r][c]){
                    // 走的路没有越界，且下一个值能匹配上才走
                    vis[r][c] = true;
                    boolean ans = dfs(board, r, c, word, wordIndex + 1);
                    vis[r][c] = false;
                    if (ans) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    private static boolean inBoard(char[][] board, int i, int j) {
        if (i >= 0 && i < board.length && j >= 0 && j < board[0].length) {
            return true;
        }
        return false;
    }
}