面试题12：矩阵中的路径

矩阵中的路径

题目描述

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

思路一：BFS形式

这里借用牛客网上的题目，所以有个创建字符矩阵的方法。
已经访问过的位置可以用一个二维 boolean 数组来标记，也可以替换字符。需要注意的是，替换字符要在搜索完成后恢复原字符。

public class Solution {
    private static int rows;
    private static int cols;
    private static int[] dx = {-1, 0, 1, 0};
    private static int[] dy = {0, 1, 0, -1};
 
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
        if (matrix == null || rows == 0)
            return false;
        this.rows = rows;
        this.cols = cols;
        char[][] grid = buildMatrix(matrix);
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                if (helper(grid, i, j, str, 0))
                    return true;
            }
        }
        return false;
    }
 
    private boolean helper(char[][] matrix, int r, int c, char[] str, int index) {
        if(matrix[r][c]!=str[index])    
            return false;
        if (index == str.length-1)
            return true;
        char t = matrix[r][c];
        matrix[r][c] = '#';
        for (int dir = 0; dir < 4; ++dir) {
            int x = r + dx[dir], y = c + dy[dir];
            if (x >= 0 && x < rows && y < cols && y >= 0) {
                if (helper(matrix, x, y, str, index + 1))
                    return true;
            }
        }
        matrix[r][c] = t;
        return false;
    }
 
    private char[][] buildMatrix(char[] array) {
        char[][] matrix = new char[rows][cols];
        for (int r = 0, idx = 0; r < rows; r++)
            for (int c = 0; c < cols; c++)
                matrix[r][c] = array[idx++];
        return matrix;
    }
 
}

思路二：回溯形式

class Solution {
    private static int rows, cols;

    public boolean hasPath(char[][] matrix, String str) {
        if (matrix == null || matrix.length == 0)
            return false;
        rows = matrix.length;
        cols = matrix[0].length;
        char[] s = str.toCharArray();
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                if (backtrack(matrix, i, j, s, 0))
                    return true;
            }
        }
        return false;
    }

    private boolean backtrack(char[][] matrix, int i, int j, char[] s, int index) {
        if (index == s.length)
            return true;
        boolean res = false;
        if (i >= 0 && i < rows && j >= 0 && j < cols && matrix[i][j] != '#' && s[index] == matrix[i][j]) {
            char temp = matrix[i][j];
            matrix[i][j] = '#';
            ++index; 
            // 检查下一个字符
            res = backtrack(matrix, i + 1, j, s, index) ||
                    backtrack(matrix, i, j + 1, s, index) ||
                    backtrack(matrix, i - 1, j, s, index) ||
                    backtrack(matrix, i, j - 1, s, index);
            // 从当前位置遍历没有找到时，要还原字符
            if (!res) {
                --index;
                matrix[i][j] = temp;
            }
        }
        return res;
    }
}