回溯法

剑指offer

1. 矩阵中的路径

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

class Solution:
    def findpath(self,matrix,rows,cols,i,j,path):
        global visited
        index = i * cols + j 
        if not path:
            return True
        haspath = False
        if i >= 0 and i < rows and j >= 0 and j < cols and not visited[index] and matrix[index] == path[0]:
            visited[index] = True
            haspath = self.findpath(matrix,rows,cols,i + 1,j,path[1:]) or self.findpath(matrix,rows,cols,i - 1,j,path[1:]) or self.findpath(matrix,rows,cols,i,j + 1,path[1:]) or self.findpath(matrix,rows,cols,i,j - 1,path[1:])
            if not haspath:
                visited[index] = False
        return haspath

    def hasPath(self, matrix, rows, cols, path):
        # write code here
        if not matrix or not path:
            return False
        global visited
        visited = [False] * rows * cols
        for i in xrange(rows):
            for j in xrange(cols):
                if self.findpath(matrix,rows,cols,i,j,path):
                    return True
        return False

寻找最优路径时，回溯法的精髓在于：

尝试不成功时，能够回退原先版本

if not haspath:
    visited[index] = False

这2行代码就完成了回退。

2. 机器人的运动范围

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

class Solution:
    def getDigit(self,k):
        s = 0
        while k != 0:
            s = s + k % 10
            k = k // 10
        return s
    def canArrival(self,threshold, rows, cols,i,j):
        global visited
        if i >= 0 and i < rows and j >= 0 and j< cols and  not visited[i * cols + j] and (self.getDigit(i) + self.getDigit(j)) <= threshold:
            visited[i * cols + j] = True
            return 1 + self.canArrival(threshold, rows, cols,i + 1,j) + self.canArrival(threshold, rows, cols,i - 1,j) + self.canArrival(threshold, rows, cols,i,j + 1) + self.canArrival(threshold, rows, cols,i,j - 1)
        return 0
    def movingCount(self, threshold, rows, cols):
        # write code here
        global visited
        
        visited = [False] * rows * cols
        if threshold <= 0 or rows < 0 or cols < 0:
            return 0
        return self.canArrival(threshold, rows, cols,0,0)

该题与上一回溯不同,在于探索的是全局可行的区域，返回总数；

于是乎，从某一点开始，遇到不可达区域时，返回0，可达区域时加1；

而上一题时找全局中是否存在可行路径，因而没有找到时，必须回溯原始位置再接着探索。