剑指offer笔记11：矩阵中的路径（Python）

剑指offer笔记11：矩阵中的路径（P89）

题目：矩阵中的路径

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

问题分析

利用回溯法解决此类问题，将所有选项用树来表示：
如下矩阵，判断矩阵中是否存在 ‘bfce’ 的路径

所有选项的树形表示如下：

从矩阵中第一行第二列的 b 开始分析：
Ps：需要一个和矩阵大小相同的布尔矩阵来记录该位置是否被访问过，和一个记录路径长度的变量

从 b 开始（路径长度=1，已访问），接下来的可选项为：
a ← b ：不在路径上，不符合
b ↓ f ：符合
b → t ：不在路径上，不符合
继续探索 f

从 f 开始（路径长度+1=2，已访问），接下来的可选项为：
f ↑ b ： 已访问，不符合
c ← f ：符合
f ↓ d ： 不在路径上，不符合
f → c ： 符合
继续探索 c（左）、c（右）

从 c（左） 开始（路径长度+1=3，已访问），接下来的可选项为：
c ↑ a ： 不在路径上，不符合
c ↓ j ： 不在路径上，不符合
c → f ：已访问，不符合
c（左） 往下没有可选项了（路径长度-1=2，标记未访问）

从 c（右） 开始（路径长度+1=3，已访问），接下来的可选项为：
c ↑ t ：不在路径上，不符合
f ← c ： 已访问，不符合
c ↓ e ： 符合
c → s ： 不在路径上，不符合
继续探索 e

从 e 开始（路径长度+1=4，已访问）：
探索到 e 为止，路径长度刚好等于字符串长，表示 e 为字符串 ‘bfce’ 的最后一个字符，终止探索。

整理一下通用的递归方法：
假设当前探索到路径上的第 i 个字符 c
首先判断 c 是否为字符串中第 i 个字符，是否访问过：
是：递归探索与 c 相邻的位置
否：退回到路径中第 i-1 处

python 代码

# -*- coding:utf-8 -*-
class Solution:
    def hasPath(self, matrix, rows, cols, path):
        # 判断矩阵中的路径
        if len(matrix) == 0 or rows < 1 or cols < 1 or path == '':
            return False
        # 设置一个访问矩阵，全部元素初始化为False
        visited = [False for _ in range(rows*cols)]
        # 用pathLength表示矩阵中已找到的路径长度
        pathLength = 0
        # 当前遍历的行列
        row = 0
        col = 0
        # 遍历matrix
        for row in range(rows):
            for col in range(cols):
                # 若从矩阵中的该位置开始，存在路径，则返回True
                if self.hasPathCore(matrix, rows, cols, row, col, path, pathLength, visited):
                    return True
        del visited
        return False

    def hasPathCore(self, matrix, rows, cols, row, col, path, pathLength, visited):
        # 判断从某位置起是否存在路径
        # 设置代表是否存在路径的布尔值hasPath，初始化为False
        hasPath = False
        # 若矩阵中当前位置的字符=字符串中第pathLength个的字符，且该位置没有被访问过
        if 0 <= row < rows and 0 <= col < cols \
                and matrix[row*cols+col] == path[pathLength] \
                and not visited[row*cols+col]:
            # 路径长度+1，标记为已访问
            pathLength += 1
            visited[row*cols+col] = True
            # 若当前访问的就是path中的最后一个字符，则直接返回True
            if pathLength == len(path) and matrix[row * cols + col] == path[-1]:
                return True
            # 从当前位置递归地搜索
            hasPath = self.hasPathCore(matrix, rows, cols, row-1, col, path, pathLength, visited) \
                      or self.hasPathCore(matrix, rows, cols, row, col+1, path, pathLength, visited) \
                      or self.hasPathCore(matrix, rows, cols, row+1, col, path, pathLength, visited) \
                      or self.hasPathCore(matrix, rows, cols, row, col-1, path, pathLength, visited)
            if hasPath is False:
                # 若从当前位置开始，没有找到符合要求的路径，则返回到上一个，并且将其标为未访问
                pathLength -= 1
                visited[row*cols+col] = False
        return hasPath

代码注释

书中给出的写法，用python写，在牛客网上的测试是不通过的
这里对书中给出的 hasPathCore(self, matrix, rows, cols, row, col, path, pathLength, visited)里的 if(str[pathLength]=='\0') return true调整到了

if 0 <= row < rows and 0 <= col < cols \
                and matrix[row*cols+col] == path[pathLength] \
                and not visited[row*cols+col]:

内的

			pathLength += 1
            visited[row*cols+col] = True

的后面一行（代码的第35行），即确定了当前访问的字符是符合要求的，并将其纳入路径内，标记为已访问后，判断其是否为给出路径的最后一个字符，如果是，则直接返回True。修改后的代码可以通过牛客网的测试。