题目

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。

路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。

如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。

注意：

• 输入的路径不为空；
• 所有出现的字符均为大写英文字母；

数据范围

矩阵中元素的总个数 [0,900][0,900]。
路径字符串的总长度 [0,900][0,900]。

样例

matrix=
[
  ["A","B","C","E"],
  ["S","F","C","S"],
  ["A","D","E","E"]
]

str="BCCE" , return "true" 

str="ASAE" , return "false"

解析

直接dfs就可

代码

C++

class Solution {
public:
    bool dfs(vector<vector<char>>& matrix, string &str, int u, int x, int y) {
        if (str[u] != matrix[x][y])
            return false;
        if (u == str.size() - 1)
            return true;
            
        char t = matrix[x][y];
        matrix[x][y] = '*';
        
        int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
        
        for (int i = 0; i < 4; i ++ ) {
            int a = x + dx[i], b = y + dy[i];
            if (a < 0 || a >= matrix.size() || b < 0 || b >= matrix[a].size())
                continue;
            if (dfs(matrix, str, u + 1, a, b))
                return true;
        }
        
        matrix[x][y] = t;
        return false;
    }
    bool hasPath(vector<vector<char>>& matrix, string str) {
        for (int i = 0; i < matrix.size(); i ++ )
            for (int j = 0; j < matrix[0].size(); j ++ )
                if (dfs(matrix, str, 0, i, j))
                    return true;
        return false;
    }
};

Python

class Solution(object):
    def dfs(self, matrix, u, string, x, y):
        if matrix[x][y] != string[u]:
            return False
        if u == len(string) - 1:
            return True
            
        dx, dy = [-1, 0, 1, 0], [0, 1, 0, -1]
        
        t = matrix[x][y]
        matrix[x][y] = '*'
        
        for i in range(4):
            a, b = x + dx[i], y + dy[i]
            
            if a < 0 or a >= len(matrix) or b < 0 or b >= len(matrix[a]):
                continue
            
            if self.dfs(matrix, u + 1, string, a, b):
                return True
            
        matrix[x][y] = t
        # return False
        
    def hasPath(self, matrix, string):
        """
        :type matrix: List[List[str]]
        :type string: str
        :rtype: bool
        """
        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                if self.dfs(matrix, 0, string, i, j):
                    return True
        return False
        

GO

func hasPath(matrix [][]byte, str string) bool {
    var dfs func(int, int, int) bool
    dfs = func(u, x, y int) bool {
        if str[u] != matrix[x][y] {
            return false
        }
        if u == len(str) - 1 {
            return true
        }
        
        t := matrix[x][y]
        matrix[x][y] = '*'
        dx, dy := []int{-1, 0, 1, 0}, []int{0, 1, 0, -1}
        
        for i := 0; i < 4; i ++ {
            a, b := x + dx[i], y + dy[i]
            if a < 0 || a >= len(matrix) || b < 0 || b >= len(matrix[0]) {
                continue
            }
            if dfs(u + 1, a, b) {
                return true
            }
        }
        matrix[x][y] = t
        return false
    }
    
    for i:= 0; i < len(matrix); i ++ {
        for j := 0; j < len(matrix[0]); j ++  {
            if dfs(0, i, j) {
                return true
            }
        }
    }    
    return false
}