剑指offer面试题12(java版):矩阵中的路径

welcome to my blog

剑指offer面试题12(java版):矩阵中的路径

题目描述

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

第四次做; DFS,回溯法:改变现场, 恢复现场

//暴力递归; 回溯法:改变现场, 恢复现场
class Solution {
    public boolean exist(char[][] board, String word) {
        //input check
        //
        int rows = board.length, cols = board[0].length;
        //记录走过的路
        boolean[][] flag = new boolean[rows][cols];
        boolean res = false;
        for(int i=0; i<rows; i++){
            for(int j=0; j<cols; j++){
                res = core(flag, board, word, i, j, 0);
                if(res)
                    return true;
            }
        }
        return false;
    }
    
    private int[][] moves = {{-1,0}, {1,0}, {0,-1}, {0,1}};
    
    //递归函数逻辑: 判断board[i][j]是否等于word.charAt(index), 等于的话继续判断(i,j)的四周是否等于word.charAt(index+1), 不等于的话返回false
    //递归函数逻辑: 判断word是否在board中, 先判断board[i][j]是否等于word.charAt(index), 等于的话继续判断(i,j)的四周是否等于word.charAt(index+1), 不等于的话返回false
    private boolean core(boolean[][] flag, char[][] board, String word, int i, int j, int index){
        //base case
        if(index == word.length())
            return true;
        //坐标不合格 || 索引不合格 || 字符不匹配
        if(i<0 || i>=board.length || j<0 || j>=board[0].length || flag[i][j]==true || board[i][j] != word.charAt(index))
            return false;
        //改变现场
        flag[i][j] = true;
        boolean res;
        //上下左右
        for(int[] m : moves){
            int x = i + m[0], y = j + m[1];
            res = core(flag, board, word, x, y, index+1);
            if(res)
                return true;
        }
        //恢复现场
        flag[i][j] = false;
        return false;
    }
}

思路

见注释

复杂度

• 时间复杂度:O(n^3)?
• 空间复杂度:O(n)

第三次做, 如果程序陷入了死循环: 检查递归终止条件; 检查for,while循环条件是否写错, 我这次写错了for的条件

/*
进入现场, 改变状态
无效离开现场, 恢复状态
*/
public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
    {
        if(matrix==null || matrix.length==0 || str==null || str.length==0 || str.length > rows*cols)
            return false;
        //
        boolean res = false;
        boolean[] flag = new boolean[rows*cols];
        for(int i=0; i<rows; i++){
            //一开始错写成i<cols
            for(int j=0; j<cols; j++){
                res = Core(matrix, rows, cols, str, flag, i, j, 0);
                if(res==true)
                    return true;
            }
        }
        return res;
    }
    public boolean Core(char[] matrix, int rows, int cols, char[] str, boolean[] flag, int i, int j, int index){
        if(index == str.length)
            return true;
        int coordinate = i*cols+j;
        if(i<0 || i>= rows || j<0 || j>=cols || flag[coordinate]==true ||matrix[coordinate] != str[index])
            return false;
        //标记该点为访问过状态
        flag[coordinate] = true;
        boolean res = Core(matrix, rows, cols, str, flag, i-1, j, index+1) ||
            Core(matrix, rows, cols, str, flag, i+1, j, index+1) ||
            Core(matrix, rows, cols, str, flag, i, j-1, index+1) ||
            Core(matrix, rows, cols, str, flag, i, j+1, index+1);
        if(res==true)
            return true;
        //恢复状态
        flag[coordinate] = false;
        return false;
    }
}

第二次做, 核心: 递归函数一次只会探索一条路径, 并不是同时探索多条路径, 所以用一个boolean[] flag即可, 但是如果某条路径行不通, 最后要把路径上标记为true的点要恢复成false

• 每个点都可以作为路径起点, 所以递归入口有rows*cols个
• 二维坐标转一维坐标

/*
暴力递归
最开始写的版本问题出在: 某一条路径行不通后, 访问过的坐标没有重新标识为未访问过
*/
public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
    {
        //input check
        if(rows*cols < str.length)
            return false;
        //
        //标识哪个格子被访问过
        boolean[] flag = new boolean[rows*cols];
        int temp;//矩阵坐标对应的一维索引
        boolean res = false;
        for(int i=0; i<rows; i++){
            for(int j=0; j<cols; j++){
                res = Core(matrix, rows, cols, i, j, str, 0, flag);
                if(res==true)
                    return true;
            }
        }
        return false;
    }
    public boolean Core(char[] matrix, int rows, int cols, int i, int j, char[] str, int index, boolean[] flag){
        //base case
        if(index==str.length)
            return true;
        if(i<0 || i>rows-1 || j <0 || j>cols-1)
            return false;
        //
        int temp = i*cols + j;
        if(flag[temp]==true)
            return false;
        if(matrix[temp]!=str[index])
            return false;
        flag[temp] = true;
        boolean res = false;;
        res = Core(matrix, rows, cols, i-1, j, str, index+1, flag) || Core(matrix, rows, cols, i+1, j, str, index+1, flag)||
            Core(matrix, rows, cols, i, j-1, str, index+1, flag)|| Core(matrix, rows, cols, i, j+1, str, index+1, flag);
        if(res==true)
            return true;
        //从该点出发没有找到匹配的路径; 标记为没有访问过
        flag[temp] = false;
        return false;
    }
}

public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
    {   // 标志位:表示matrix当前坐标是否可以到达,初始全为true,表示都可以到达  
        boolean[] flag =  new boolean[matrix.length];
        for(int i=0; i<flag.length; i++)
            flag[i]=true;
        // 逐个以matrix的元素为路径起点进行回溯搜索
        for(int i=0; i<rows; i++)
            for(int j=0; j<cols; j++){
                if(recallMethod(matrix, rows, cols, i, j, str, 0, flag))
                    return true;
            }
        // 调出循环说明没有这样的路径,返回false
        return false;
    }
    // i,j分别为matrix的行坐标和纵坐标,从0开始
    // char_index表示str中char的索引
    public boolean recallMethod(char[] matrix, int rows, int cols, int i, int j, char[] str, int char_index, boolean[] flag){
        // 将二维坐标转换为一维坐标
        int index = i*cols + j;
        // 搜索失败,返回false的情况: i,j坐标越界;(i,j)表示的元素跟str[char_index]不同;(i,j)位置不可到达
        if(i<0 || i >=rows || j<0 || j>=cols || matrix[index]!=str[char_index] || flag[index]==false)
            return false;
        // 跳过上面的if,说明当前matrix[index]==str[char_index]; 如果char_index是str的末尾,说明路径匹配完毕,返回true; 否则需要判断(i,j)的上下左右是否和str[char_index+1]相同
        // 
        if(char_index == str.length-1)
            return true; // 这个true是最关键的,代表找到了匹配的路径
        // 搜索下一个点时,当前点就不能访问了
        flag[index]=false;
        if(recallMethod(matrix, rows, cols, i+1, j, str, char_index+1, flag) ||
          recallMethod(matrix, rows, cols, i-1, j, str, char_index+1, flag) ||
           recallMethod(matrix, rows, cols, i, j+1, str, char_index+1, flag) ||
           recallMethod(matrix, rows, cols, i, j-1, str, char_index+1, flag))
            return true;
        // 执行到这里表示(i,j)的上下左右点都不满足条件,这个点还能访问,重新表为true
        // 但是从这个点往下匹配不到路径了,返回false,向上回溯
        flag[index]=true;
        return false;
    }
}