遍历矩阵并以 K 步返回原点的方法计数

在某些编程问题中，需要计算从一个点出发，在矩阵或棋盘等二维结构上移动 k 步后返回原点的方案数。下面我们将介绍两种方法：暴力遍历和动态规划。

暴力遍历

最简单的方法就是暴力遍历所有可行的路径，统计返回原点的方案数。这里提供一个递归实现，对于每个点，可以向上、下、左、右四个方向移动，一直递归直到步数为 0，返回原点则算作一种方案。

def countPaths(x, y, k):
    if k == 0:
        return 1 if x == 0 and y == 0 else 0
    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
    res = 0
    for dx, dy in directions:
        nx, ny = x + dx, y + dy
        if 0 <= nx < n and 0 <= ny < m:
            res += countPaths(nx, ny, k - 1)
    return res

这个算法的时间复杂度为 $O(4^k)$，空间复杂度为 $O(k)$，随着 k 增加，计算复杂度呈指数级增加，只适用于 k 很小的情况。

动态规划

动态规划是一种重复利用已经计算过的结果来优化计算的方法。在这个问题中，可以使用一个二维数组 dp[i][j][k] 表示从起点到 (i, j) 使用 k 步返回起点的方案数，根据每一步可以向四个方向移动，可以写出状态转移方程：

$$dp[i][j][k] = \sum_{(dx, dy) \in \text{directions}} dp[i-dx][j-dy][k-1]$$

其中 directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]为四个方向。

根据初始条件 dp[0][0][0] = 1，可以根据状态转移方程逐层计算得到 dp[0][0][k]。

def countPathsDP(n: int, m: int, k: int) -> int:
    dp = [[[0] * (k + 1) for _ in range(m)] for _ in range(n)]
    dp[0][0][0] = 1
    for step in range(1, k + 1):
        for i in range(n):
            for j in range(m):
                for dx, dy in directions:
                    ni, nj = i - dx, j - dy
                    if 0 <= ni < n and 0 <= nj < m:
                        dp[i][j][step] += dp[ni][nj][step - 1]
    return dp[0][0][k]

这个算法的时间复杂度为 $O(nmk)$，空间复杂度为 $O(nmk)$，和 k 无关，适合于 k 较大的情况。