剑指 Offer 12. 矩阵中的路径

Sumxmq

于 2022-04-28 08:00:00 发布

阅读量177

点赞数

分类专栏： LeetCode-剑指Offer 文章标签： java 算法

本文链接：https://blog.csdn.net/m0_51957892/article/details/124434480

版权

LeetCode-剑指Offer 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

剑指 Offer 12. 矩阵中的路径

题目描述：

给定一个 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 + 剪枝

题目的意思可以理解为：在一个字符矩阵中，选定一个点，不重复的走，走过的路径连起来，得到一个字符串。题目问由这个矩阵产生的字符中，是否存在与给定字符串相等的情况，如果有则返回true，否则返回false

因此我们遍历一遍字符数组，如果找到一个位置的值和给定字符串的首字符相等，我们就可以试着从这一个点开始，看能不能得到目标的字符串。

至于如何判断从一个点开始，能否走出要求的字符串，我们可以采用DFS的方法

我们知道一个点可以往他的上下左右四个方向进行移动，那么，我们就可以判断，对于一个点的某个方向，如果他满足下列要求，那么我们就可以往这个点的方向走：

这个点的下标处于表格的范围
这个点在之前没有被走过
这个点上的值，和目标字符串中的下一位字符的值相等

如果满足上述条件，我们就可以试着往这个点的方向走一步。

如果在某一时刻，一点的四个方向都不符合这个条件，那么就证明这个方案是行不通的，我们就抛弃这个点，回溯，然后向别的点尝试；

如果在某一时刻，我们走出来和目标字符串相同的序列，那么我们就可以打上一个标记，标记着这个表是可以走出目标字符串的，然后我们就可以退出所有生在运行的DFS函数，因为已经取得了正确答案，这些函数就没有运行的必要了，最后，我们只要返回这个标记（标记初始化为false）即可。

然后我们有一个小小的优化方案：我们在开始运算前，统计一下board和word中的所有字符出现的次数，如果存在一个字符在word中出现的频数大于在board中出现的频数，那么无论如何，我们都是无法从board中走出word的，因此，我们就可以直接返回一个false

N、M为board的行列数，k为word的长度

时间复杂度：O(3^k * NM)（由于一个点有四个方向，舍弃回头方向，在最坏情况下，有3种可能）

空间复杂度：O(k)

代码：

class Solution {
    private int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; // 四个方向
    private int n = 0, len_n = 0, len_m = 0;
    private char[] c;   // 保存word字符串
    private boolean flag = false;   // 结果
    private boolean[][] h = new boolean[205][205];  // 用于标记某个点是否走过

    public boolean exist(char[][] board, String word) {
        // 记录长度信息 和 字符串
        n = word.length();
        len_n = board.length;
        len_m = board[0].length;
        c = new char[n];
        for (int i = 0; i < n; i++){
            c[i] = word.charAt(i);
        }
        // 进行字符个数的特判
        int[] board_char = new int[128];
        int[] word_char = new int[128];
        Arrays.fill(board_char, 0);
        Arrays.fill(word_char, 0);
        for (int i = 0; i < n; i++){
            word_char[(int)c[i]]++;
        }
        for (int i = 0; i < len_n; i++){
            for (int j = 0; j < len_m; j++){
                board_char[(int)board[i][j]]++;
            }
        }
        for (int i = 0; i < 128; i++){
            if (board_char[i] < word_char[i]){
                return false;
            }
        }
        // 初始化
        for (int i = 0; i < len_n; i++){
            for (int j = 0; j < len_m; j++){
                h[i][j] = true;
            }
        }
        for (int i = 0; i < len_n; i++){
            for (int j = 0; j < len_m; j++){
                if (board[i][j] == word.charAt(0)){ // 判断第一个数，之后开始递归
                    h[i][j] = false;
                    su(i, j, 1, n, board);
                    h[i][j] = true;
                }
            }
        }
        return flag;
    }

    void su(int x, int y, int k, int n, char[][] map){
        if (k == n || flag){
            flag = true;
            return;
        }

        for (int i = 0; i < 4; i++){ // 遍历四个方向
            int x_pos = x + dir[i][0];
            int y_pos = y + dir[i][1];
            if (x_pos >= 0 && x_pos < len_n){
                if (y_pos >= 0 && y_pos < len_m){
                    if (h[x_pos][y_pos] && map[x_pos][y_pos] == c[k]){  // 判断该方向的点是否符合要求
                        h[x_pos][y_pos] = false;
                        su(x_pos, y_pos, k + 1, n, map);
                        h[x_pos][y_pos] = true;
                    }
                }
            }
        }
    }
}