附可运行代码剑指 Offer 12. 矩阵中的路径

Posted 2021-06-27 来老铁干了这碗代码

立志用最少的代码做最高效的表达

---

给定一个 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 仅由大小写英文字母组成

---

优化过程

1、定义成员变量（全局变量），避免回溯方法用二维数组做参数，占用大量内存。
2、灵活使用剪枝，具体见代码。

    public class Solution {
        char[][] bo;        // 数组board
        char[] wo;          // 数组word
        boolean[][] vis;       // vis数组
        int next[][];
        int n, m;

        boolean flag = false;
        public boolean exist(char[][] board, String word) {
            // 特殊情况判断
            if(board.length == 0) return false;

            bo = board;
            wo = word.toCharArray();
            n = bo.length;  m = bo[0].length;
            vis = new boolean[n][m];
            next = new int[][]{{1,0}, {-1,0}, {0,-1},{0,1}};

            for(int i = 0; i < n; i++) {
                for(int j = 0; j < m; j++) {
                    if(wo[0] == bo[i][j]) {
                        vis[i][j] = true;
                        dfs(i, j, 1);
                        vis[i][j] = false;
                    }
                    // 每次搜索后都判断是否已经找到
                    if(flag) return true;
                }
            }
            return false;
        }
        public void dfs(int x, int y, int k) {
            // 1、终止条件
            // k == len，终止
            // res 如果已经找到，则直接return（剪枝）
            if(k == wo.length || flag) {
                flag = true; return;
            }

            for(int d = 0; d < 4; d++) {
                int xx = x + next[d][0], yy = y + next[d][1];
                // 越界 or 被访问过 or 不匹配
                if(xx < 0 || yy < 0 || xx >= n || yy >= m || vis[xx][yy] || bo[xx][yy]!=wo[k]) continue;

                vis[xx][yy] = true;
                dfs(xx, yy, k+1);
                vis[xx][yy] = false;

            }
        }
    }

可运行代码

// 静态Solution
public class 剑指Offer12_矩阵中的路径 {
    public static class Solution {
        char[][] bo;        // 数组board
        char[] wo;          // 数组word
        boolean[][] vis;       // vis数组
        int next[][];
        int n, m;

        boolean flag = false;
        public boolean exist(char[][] board, String word) {
            // 特殊情况判断
            if(board.length == 0) return false;

            bo = board;
            wo = word.toCharArray();
            n = bo.length;  m = bo[0].length;
            vis = new boolean[n][m];
            next = new int[][]{{1,0}, {-1,0}, {0,-1},{0,1}};

            for(int i = 0; i < n; i++) {
                for(int j = 0; j < m; j++) {
                    if(wo[0] == bo[i][j]) {
                        vis[i][j] = true;
                        dfs(i, j, 1);
                        vis[i][j] = false;
                    }
                    // 每次搜索后都判断是否已经找到
                    if(flag) return true;
                }
            }
            return false;
        }
        public void dfs(int x, int y, int k) {
            // 1、终止条件
            // k == len，终止
            // res 如果已经找到，则直接return（剪枝）
            if(k == wo.length || flag) {
                flag = true; return;
            }

            for(int d = 0; d < 4; d++) {
                int xx = x + next[d][0], yy = y + next[d][1];
                // 越界 or 被访问过 or 不匹配
                if(xx < 0 || yy < 0 || xx >= n || yy >= m || vis[xx][yy] || bo[xx][yy]!=wo[k]) continue;

                vis[xx][yy] = true;
                dfs(xx, yy, k+1);
                vis[xx][yy] = false;

            }
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();

        char[][] board = {{'a','b','c','e'},{'s','f','c','s'},{'a','d','e','e'}};
        String word = "abcced";
        System.out.println(solution.exist(board, word));
    }
}