用1填充整个矩阵所需的最短时间

这是一个经典的问题，也是一个比较常见的算法题目，常见的解决方案有动态规划和广度优先搜索。下面分别介绍这两种解决方案。

动态规划

思路

设 $dp[i][j]$ 表示位置 $(i,j)$ 用 $1$ 填充整个矩阵所需的最短时间。此时，我们考虑 $dp[i][j]$ 的转移方程。我们观察到，对于一个位置 $(i,j)$，它的格外上下左右四个方向是会对它产生影响的，因为填充这个位置需要用到它的上下左右四个相邻位置的值。因此，我们可以分别计算填充这个位置时，分别用它的上下左右四个相邻位置的值填充所需要的最短时间，然后取最小值即可。具体而言，我们有如下转移方程：

$$dp[i][j] = \min {dp[i-1][j], dp[i+1][j], dp[i][j-1], dp[i][j+1]} + 1$$

当然，在计算转移方程时，需要特别注意边缘情况（位置 $(i,j)$ 处于矩阵的边缘）。

代码实现

def fill_with_ones(matrix):
    m, n = len(matrix), len(matrix[0])
    dp = [[float('inf')] * n for _ in range(m)]
    
    for i in range(m):
        for j in range(n):
            if matrix[i][j] == 1:
                dp[i][j] = 0
            else:
                if i > 0:
                    dp[i][j] = min(dp[i][j], dp[i-1][j] + 1)
                if i < m-1:
                    dp[i][j] = min(dp[i][j], dp[i+1][j] + 1)
                if j > 0:
                    dp[i][j] = min(dp[i][j], dp[i][j-1] + 1)
                if j < n-1:
                    dp[i][j] = min(dp[i][j], dp[i][j+1] + 1)
    
    return dp

广度优先搜索

思路

另一个可行的解决方案就是使用 BFS（广度优先搜索） 算法。具体而言，我们可以从所有的格子（即初始状态）开始，每次将距离当前格子的距离为 $k$ 的格子加入队列，直到队列为空。在处理队列中的格子时，我们根据当前格子的距离，更新它周围的格子的距离（如上述动态规划算法中的转移方程），同时用一个 visited 数组来记录每个格子是否已经被更新过。最终，visited 数组中存储的就是每个格子用 $1$ 填充整个矩阵所需的最短时间。

代码实现

from collections import deque

def fill_with_ones(matrix):
    m, n = len(matrix), len(matrix[0])
    visited = [[False] * n for _ in range(m)]
    
    queue = deque()
    for i in range(m):
        for j in range(n):
            if matrix[i][j] == 1:
                queue.append((i, j, 0))
                visited[i][j] = True
    
    while queue:
        i, j, distance = queue.popleft()
        
        if matrix[i][j] == 0:
            visited[i][j] = True
        
        if i > 0 and not visited[i-1][j]:
            queue.append((i-1, j, distance+1))
            visited[i-1][j] = True
        if i < m-1 and not visited[i+1][j]:
            queue.append((i+1, j, distance+1))
            visited[i+1][j] = True
        if j > 0 and not visited[i][j-1]:
            queue.append((i, j-1, distance+1))
            visited[i][j-1] = True
        if j < n-1 and not visited[i][j+1]:
            queue.append((i, j+1, distance+1))
            visited[i][j+1] = True
    
    return visited

至此，我们就介绍完了两种解决方案。需要注意的是，这两种算法的时间复杂度理论上都是 $O(mn)$ 级别的，实际运行时也能达到比较优秀的效果。当然，使用 BFS 的算法在实际运行时可能会占用比较大的空间，因为需要记录每个格子的状态。