附加题 66-68

面试题66：矩阵中的路径

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

思路梳理（回溯法）

1. 判断每个输入变量的异常情况，返回 False；
2. 遍历输入矩阵中的每一个元素，查看该元素作为路径起点的匹配情况，
   3. 递归调用子方法去匹配整个字符串；
   4. 如果当前字符匹配，则递归调用子方法去匹配上、下、左、右四个方向；
   5. 如果当前字符不匹配，则返回False，回到主函数的遍历矩阵模块，继续匹配下一个字符为起点的路径。
   6. 增加一个已匹配字符串的长度的变量 pathLength，如果 pathLength==len(path)，返回 True。
3. 如果整个矩阵遍历之后，仍未返回值，则未匹配到字符串，返回 False。

# -*- coding:utf-8 -*-
class Solution:
    def match(self, matrix, rows, cols, path, visited, i, j, pathlength):
        # 如果已匹配的路径长度等于总路径长度，直接返回True
        if pathlength == len(path):
            return True
        hasPath = False
        # 判断当前索引是否合法，是否已经被访问过，是否可以匹配当前元素
        if i<rows and i>=0 and j<cols and j>=0 and matrix[i*cols+j] == path[pathlength] and not visited[i*cols+j]:
            pathlength += 1
            visited[i*cols+j] = True
            
            # 从四个方向上，递归匹配下一个元素，
            hasPath = self.match(matrix, rows, cols, path, visited, i+1, j, pathlength) or self.match(matrix, rows, cols, path, visited, i-1, j, pathlength) or self.match(matrix, rows, cols, path, visited, i, j+1, pathlength) or self.match(matrix, rows, cols, path, visited, i, j-1, pathlength) 
            
            # 如果不能匹配，返回 False
            if not hasPath:
                pathlength -= 1
                visited[i*cols+j] = False
                
        return hasPath
            
        
    def hasPath(self, matrix, rows, cols, path):
        if matrix == None or rows < 1 or cols < 1 or path == None:
            return False
        flag1 = [False]*rows * cols
        for r in range(rows):
            for c in range(cols):
                if self.match(matrix, rows, cols, path, flag1, r, c, 0):
                    return True
        return False                

面试题67：机器人的运动范围

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

思路梳理（回溯法）

类似于面试题66。把方格看成一个m*n的矩阵，从（0，0）开始移动。当准备进入坐标(i, j)是，通过检查坐标的数位来判断机器人能否进入。如果能进入的话，接着判断四个相邻的格子。

• 定义子方法，判断当前位置的合法性；
• 主方法从索引 (0, 0) 开始进入子方法，递归地寻找可用路径：
  • 定义变量 count 记录可用格子的数量，注意count的更新表达式。如果当前格子可以进入，则递归判断上、下、左、右四个方向的相邻格子。
    grid_cnt = 1+self.movCntCore(threshold, rows, cols, r+1, c, visited) + self.movCntCore(threshold, rows, cols, r, c+1, visited) + self.movCntCore(threshold, rows, cols, r-1, c, visited) + self.movCntCore(threshold, rows, cols, r, c-1, visited)
  • 子方法返回 count 值。
    注意：visited数组的定义方式、表示方式、索引方式。visited[r * cols + c]

# -*- coding:utf-8 -*-
class Solution:
    def calcSum(self, loc):
        res = 0
        # 当loc不为零时
        while loc:
            res += (loc%10)
            loc //= 10
        return res
    
    def movCntCore(self, threshold, rows, cols, r, c, visited):
        grid_cnt = 0
        if r>=0 and r<rows and c>=0 and c<cols and not visited[r * cols + c] and self.calcSum(r)+self.calcSum(c)<=threshold:
            visited[r * cols + c]=1
            
            grid_cnt = 1+self.movCntCore(threshold, rows, cols, r+1, c, visited) + self.movCntCore(threshold, rows, cols, r, c+1, visited) + self.movCntCore(threshold, rows, cols, r-1, c, visited) + self.movCntCore(threshold, rows, cols, r, c-1, visited)
            
        return grid_cnt
            
    def movingCount(self, threshold, rows, cols):
        visited = [0]*rows*cols
        return self.movCntCore(threshold, rows, cols, 0, 0, visited)