python--剑指offer--13. 机器人的运动范围

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

示例 1：

输入：m = 2, n = 3, k = 1
输出：3
示例 2：

输入：m = 3, n = 1, k = 0
输出：1

提示：
1 <= n,m <= 100
0 <= k <= 20

一个16*16的格子

方法一：

# 广度遍历
from collections import deque


class Solution_bfs:
    def movingCount(self, m: int, n: int, k: int) -> int:
        """
        思路：考虑到方法一提到搜索的方向只需要朝下或朝右，使用广度优先遍历，使用队列及循环代替递归

        时间复杂度：
                    O(mn)O(mn)，其中 m 为方格的行数，n 为方格的列数。考虑所有格子都能进入，那么搜索的时候一
                个格子最多会被访问的次数为常数，所以时间复杂度为 O(2mn)=O(mn)O(2mn)=O(mn)。

        空间复杂度：
                O(mn)，其中 m 为方格的行数，n 为方格的列数。搜索的时候需要一个大小为 O(mn)O(mn) 的标记结构
            用来标记每个格子是否被走过。

        :param m:
        :param n:
        :param k:
        :return:
        """
        temp_que = deque()
        temp_que.append((0, 0))
        visit = deque()
        while temp_que:
            cur = temp_que.pop()
            if cur not in visit and 0 <= cur[0] < m and 0 <= cur[1] < n and self.sum(cur[0]) + self.sum(cur[1]) <= k:
                visit.append(cur)
                temp_que.append((cur[0]+1, cur[1]))
                temp_que.append((cur[0], cur[1]+1))
        return len(visit)

    def sum(self, x):
        y = 0
        for i in str(x):
            y += int(i)
        return y

if __name__ == '__main__':
    solution = Solution()
    m = 2
    n = 3
    k = 1
    result = solution.movingCount(m, n, k)
    print(result)  # 3

    m = 3
    n = 1
    k = 0
    result = solution.movingCount(m, n, k)
    print(result)  # 1

    m = 3
    n = 2
    k = 17
    result = solution.movingCount(m, n, k)
    print(result)  # 6


"""
运行结果：
3
1
6

Process finished with exit code 0
"""

方法二：

# 依次遍历每个格子
from collections import deque


class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        """
        思路；
            考虑到方法一提到搜索的方向只需要朝下或朝右，我们可以得出一种递推的求解方法。
        
        算法思想：
                (1) 遍历每一个格子，若当前格子(i, j)不在visit列表中即未被访问过，且(i, j-1) 和(i-1, j)中有
            一个在visit列表中表示（i, j）可达，且self.sum(i) + self.sum(j) <= k表示格子符合要求，同时满
            足这三个条件，即可将(i, j)放入visit列表，表示已访问。
                (2) 遍历完每个格子后返回visit列表的长度即可。
            

        时间复杂度：
                O(mn)，其中 m 为方格的行数， n 为方格的列数。一共有 O(mn)个状态需要计算，每个状态
            递推计算的时间复杂度为 O(1)O(1)，所以总时间复杂度为 O(mn)O(mn)。

        空间复杂度：
                O(mn)，其中 m 为方格的行数，n 为方格的列数。我们需要 O(mn)O(mn) 大小的结构来记录
            每个位置是否可达。

        :param m:
        :param n:
        :param k:
        :return:
        """
        visit = deque()
        visit.append((0, 0))
        for i in range(m):
            for j in range(n):
                cur = (i, j)
                if cur not in visit and ((i-1, j) in visit or (i, j-1) in visit) and self.sum(i) + self.sum(j) <= k:
                    visit.append(cur)
        return len(visit)

    def sum(self, x):
        y = 0
        for i in str(x):
            y += int(i)
        return y


if __name__ == '__main__':
    solution = Solution()
    m = 2
    n = 3
    k = 1
    result = solution.movingCount(m, n, k)
    print(result)  # 3

    m = 3
    n = 1
    k = 0
    result = solution.movingCount(m, n, k)
    print(result)  # 1

    m = 3
    n = 2
    k = 17
    result = solution.movingCount(m, n, k)
    print(result)  # 6


"""
运行结果：
3
1
6

Process finished with exit code 0
"""

方法三：

# 深度遍历，改代码效率较低，还需优化
import numpy as np


class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        graph = np.zeros([m, n])

        def sum(x):
            a = 0
            for i in str(x):
                a += int(i)
            return a

        for i in range(m):
            for j in range(n):
                temp = sum(i) + sum(j)
                if temp > k:
                    graph[i][j] = 1
        print(graph)
        return self.visit(graph, 0, 0, m, n)

    def visit(self, graph, row, col, m, n):
        if row == m-1 and col == n-1 and graph[row][col] == 0:
            graph[row][col] = -1
            return 1
        if (0 <= row < m) and (0 <= col < n) and graph[row][col] == 0:
            graph[row][col] = -1
            under_result = self.visit(graph, row+1, col, m, n)
            right_result = self.visit(graph, row, col+1, m, n)
            return under_result + right_result + 1
        return 0


if __name__ == '__main__':
    solution = Solution()
    # m = 2
    # n = 3
    # k = 1
    # result = solution.movingCount(m, n, k)
    # print(result)  # 3
    #
    # m = 3
    # n = 1
    # k = 0
    # result = solution.movingCount(m, n, k)
    # print(result)  # 1

    m = 3
    n = 2
    k = 17
    result = solution.movingCount(m, n, k)
    print(result)  # 6


"""
运行结果：
3
1
6

Process finished with exit code 0
"""

[题目来源于leetcode剑指offer]