一篇文章带你搞定 Java 剑指 offer：矩阵中的路径

一、题目

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。

例如矩阵中包含一条字符串 “bcced” 的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

二、解析

主要依靠了回溯法的思想：

• 根据给定数组，初始化一个标志位数组，初始化为 false，表示未走过，true 表示已经走过，不能走第二次
• 根据行数和列数，遍历数组，先找到一个与str字符串的第一个元素相匹配的矩阵元素，进入 judge
• 根据i和j先确定一维数组的位置，因为给定的matrix是一个一维数组
• 确定递归终止条件：越界，当前找到的矩阵值不等于数组对应位置的值，已经走过的，这三类情况，都直接false，说明这条路不通
• 待判定的字符串str的索引已经判断到了最后一位，此时说明是匹配成功
• 递归不断地寻找周围四个格子是否符合条件，只要有一个格子符合条件，就继续再找这个符合条件的格子的四周是否存在符合条件的格子，直到k到达末尾或者不满足递归条件就停止

关键：
题目对应的 matrix：

char[] matrix = {'a', 'b', 'c', 'e', 's', 'f', 'c', 's', 'a', 'd', 'e', 'e'};

所以i行j列时对应的字符数组中的字符元素是：i*cols+j;

public class Test {
    public static void main(String[] args) {

        char[] matrix = {'a', 'b', 'c', 'e', 's', 'f', 'c', 's', 'a', 'd', 'e', 'e'};
        char[] str = {'b', 'c', 'c', 'e', 'd'};
        int rows = 3;
        int cols = 4;
        if (hasPath(matrix, rows, cols, str)) {
            System.out.println("找到了！！！");
        } else {
            System.out.println("没有找到！！！");
        }
    }

    public static boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
        //标志位数组，初始化为 false
        boolean[] flag = new boolean[matrix.length];
        //回溯法：循环遍历二维数组
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                //找到起点等于 str 中第一个元素的值再递归判断四周是否有符合条件的
                if (judge(matrix, i, j, rows, cols, flag, str, 0)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * judge 执行回溯递归判断从(i,j)出发的元素是否可以行得通
     *
     * @param matrix:初始矩阵
     * @param i：索引行坐标
     * @param j:索引列坐标
     * @param rows：矩阵行数
     * @param cols：矩阵列数
     * @param flag：标志位数组
     * @param str：待判断的字符串
     * @param k：字符串索引初始为  0，即先判断字符串的第一位
     * @return
     */
    private static boolean judge(char[] matrix, int i, int j, int rows, int cols, boolean[] flag, char[] str, int k) {
        //先根据i 和 j 计算匹配的第一个元素转为一维数组的位置
        int index = i * cols + j;
        if (i < 0 || j < 0 || i >= rows || j >= cols || matrix[index] != str[k] || flag[index] == true) {
            return false;
        }
        //如果k已经到达str末尾，表示前面的都匹配成功，返回 TRUE
        if (k == str.length - 1) {
            return true;
        }
        //要走的第一个位置置为TRUE，表示已经走过
        flag[index] = true;
        //回溯，递归寻找，每次找到了就给 k+1,找不到还原
        if (judge(matrix, i - 1, j, rows, cols, flag, str, k + 1) ||
                judge(matrix, i + 1, j, rows, cols, flag, str, k + 1) ||
                judge(matrix, i, j - 1, rows, cols, flag, str, k + 1) ||
                judge(matrix, i, j + 1, rows, cols, flag, str, k + 1)) {
            System.out.println(matrix[index]);
            return true;
        }
        //走到这，说明这一条路走不通，再试其他路径
        flag[index] = false;
        return false;
    }
}