填充 NxM 网格所需的最小整数数

在这个问题中，我们需要填充一个给定的 $N \times M$ 网格，使得每个单元格都有一个正整数。填充的数需要满足以下规则：

1. 每个单元格的数必须是正整数。
2. 对于任意两个单元格 $(i,j)$ 和 $(k,l)$，如果它们在同一行或同一列，则它们的数应该不同。
3. 填充的数需要尽量小。

我们的目标是找到填充网格所需的最小整数数。

解法

我们可以将问题建模为一个二分图匹配问题。将横向的单元格和竖向的单元格分别看作两个节点集合，横向单元格中的每个单元格与竖向单元格中的每个单元格都连一条边。两个单元格之间的边权为 $0$，如果它们在同一行或同一列则边权为 $1$。目标是找到一个完美匹配，使得所有边的权值和最小。

我们可以使用网络流算法来解决这个问题。具体来说，我们可以建立一个超级源点和一个超级汇点，将横向节点和竖向节点分别连向超级源点和超级汇点，并将边权设为 $1$，表示每个节点只能被填充一个数。然后我们再将每个节点连接到它所有可以走到的单元格上，并将边权设为 $0$ 或 $1$，表示是否在同一行或同一列。

然后我们可以使用最小割算法来求解最小权值和的完美匹配。最小割算法可以使用 Edmonds-Karp 算法、Ford-Fulkerson 算法等。

最后，我们可以将所有被填充的数字相加，得到填充网格所需的最小整数数。

代码实现

下面是使用 Python 语言实现上述解法的代码片段：

from collections import deque

def bfs(graph, s, t, parent):
    """
    使用广度优先搜索查找增广路径，并更新 parent 数组
    """
    visited = set()
    queue = deque([s])

    while queue:
        u = queue.popleft()
        visited.add(u)

        for v, w in graph[u]:
            if v not in visited and w > 0:
                queue.append(v)
                parent[v] = u

        if t in visited:
            break

    return t in visited

def ford_fulkerson(graph, source, sink):
    """
    使用 Ford-Fulkerson 算法求解最大流
    """
    # 初始化残留图
    residual = {u: {v: w for v, w in edges} for u, edges in graph.items()}

    # 初始化 parent 数组
    parent = {u: None for u in graph}

    max_flow = 0

    while bfs(residual, source, sink, parent):
        # 找到增广路径上的最小权值
        path_flow = float("inf")
        v = sink
        while v != source:
            u = parent[v]
            path_flow = min(path_flow, residual[u][v])
            v = u

        # 更新残留图和最大流
        v = sink
        while v != source:
            u = parent[v]
            residual[u][v] -= path_flow
            residual[v][u] += path_flow
            v = u
        max_flow += path_flow

    return max_flow

def fill_grid(n, m, grid):
    """
    给定一个 n * m 的网格 grid，返回填充该网格所需的最小整数数
    """
    # 建立节点集合
    rows = [f"row_{i}" for i in range(n)]
    cols = [f"col_{j}" for j in range(m)]

    # 建立图结构
    graph = {"source": {}, "sink": {}}
    for row in rows:
        graph[row] = {f"{row}_{col}": 0 for col in range(m)}
        graph["source"][row] = 1
    for col in cols:
        graph[col] = {f"{row}_{col}": 0 for row in range(n)}
        graph[col]["sink"] = 1
    for row in rows:
        for col in cols:
            graph[f"{row}_{col}"] = {
                "source": 0,
                row: 1,
                col: 1,
                "sink": 0,
            }

    # 运行 Ford-Fulkerson 算法，计算最小割
    min_cut = ford_fulkerson(graph, "source", "sink")

    # 计算填充网格所需的最小整数数
    return sum(grid[i][j] for i in range(n) for j in range(m)
               if (i + j) % 2 == 0 and f"row_{i}_{j}" in graph["source"]
               or (i + j) % 2 == 1 and f"col_{j}_{i}" in graph["source"])

代码中的 fill_grid 函数接受一个 $n \times m$ 的网格 grid，并返回填充该网格所需的最小整数数。该函数使用了 Ford-Fulkerson 算法和最小割定理来求解最小权值和的完美匹配问题。具体来说，函数将网格建模成一个二分图，表示为一个字典类型的图结构，然后运行 Ford-Fulkerson 算法来求解最小割。最后，函数统计所有被填充的数字，并返回它们的总和，该总和即为填充网格所需的最小整数数。