剑指offer--回溯法

题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。例如

矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.dict1 = {}

    def hasPath(self, matrix, rows, cols, path):
        x = [list(matrix[i*cols:(i+1)*cols]) for i in range(rows)]
        print(x)
        for i in range(rows):
            for j in range(cols):
                self.dict1 = {}
                if self.bfs(x, i, j, path):
                    return True
        return False

    def bfs(self, x, i, j, path):
        if not (0 <= i < len(x) and 0 <= j < len(x[0])):
            return False
        if x[i][j] != path[0]:
            return False
        if (i, j) in self.dict1:
            return False
        self.dict1[(i, j)] = 1
        if not path[1:]:
            return True
        return self.bfs(x, i-1, j, path[1:]) or \
               self.bfs(x, i+1, j, path[1:]) or \
               self.bfs(x, i, j-1, path[1:]) or \
               self.bfs(x, i, j+1, path[1:])

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

class Solution:
    def __init__(self):
        self.dict1 = {}
        self.count = 0

    def movingCount(self, threshold, rows, cols):
        # write code here
        matrix = [[1 for i in range(cols)] for j in range(rows)]
        self.dfs(matrix, 0, 0, threshold)
        return self.count

    def dfs(self, x, i, j, threshold):
        if not (0 <= i < len(x) and 0 <= j < len(x[0])):
            return False
        if self.get_sum(i, j) > threshold:
            return False
        if (i, j) in self.dict1:
            return False
        self.dict1[(i, j)] = 1
        self.count += 1
        self.dfs(x, i - 1, j, threshold) or \
        self.dfs(x, i + 1, j, threshold) or \
        self.dfs(x, i, j - 1, threshold) or \
        self.dfs(x, i, j + 1, threshold)

    def get_sum(self, i, j):
        sum1 = 0
        while i:
            sum1 += i % 10
            i = i / 10
        while j:
            sum1 += j % 10
            j = j / 10
        return sum1