Leetcode 2123. 使矩阵中的 1 互不相邻的最小操作数

1.题目基本信息

1.1.题目描述

给你一个下标从 0 开始的矩阵 grid。每次操作，你可以把 grid 中的一个 1 变成 0 。

如果一个矩阵中，没有 1 与其它的 1 四连通（也就是说所有 1 在上下左右四个方向上不能与其他 1 相邻），那么该矩阵就是完全独立的。

请返回让 grid 成为完全独立的矩阵的最小操作数。

1.2.题目地址

https://leetcode.cn/problems/minimum-operations-to-remove-adjacent-ones-in-matrix/description/

2.解题方法

2.1.解题思路

二分图+匈牙利算法求二分图的最大匹配数

二分图+Hopcroft-karp算法求二分图的最大匹配数

2.2.解题步骤

二分图+匈牙利算法步骤

第一步，构建二分图。在所有值为1的结点中，其中偶数下标行的偶数下标结点和奇数下标行的奇数下标结点为左结点集合uSet，其余结点为右结点集合vSet；uSet和vSet中彼此相邻代表一条边
第二步，执行匈牙利算法获取最大匹配数
- 匈牙利算法的步骤请看代码注释

二分图+Hopcroft-karp算法步骤

第一步，构建二分图。在所有值为1的结点中，其中偶数下标行的偶数下标结点和奇数下标行的奇数下标结点为左结点集合uSet，其余结点为右结点集合vSet；uSet和vSet中彼此相邻代表一条边
第二步，执行二分图+Hopcroft-karp算法获取最大匹配数
- Hopcroft-karp算法的步骤请看代码注释

3.解题代码

二分图+匈牙利算法代码

python 复制代码

# ==> 匈牙利算法
# params：graph：二分图的邻接表；leftNodes：二分图左集合的所有结点数组
# return：返回二分图中的最大匹配数（等于最小点覆盖数）
from collections import defaultdict
def hungarian(graph:dict[int,list[int]], leftNodes:list[int]) -> int:
    # 第一步，构建维护变量。rightMatch维护右集合中各个结点的匹配状态
    rightMatch = {}
    # 第二步，构建dfs递归函数。递归任务：判断左集合中结点u是否能成功匹配。如果u相邻结点v没有匹配，则直接匹配；如果v已经匹配，则将v标记为已访问，dfs(match[v])观察是否能让match[v]结点匹配非v结点来释放v结点，让u进行匹配，即贪心地进行匹配。
    def dfs(u:int) -> bool:
        # 2.1.枚举u的相邻的右集合结点v
        for v in graph[u]:
            # 2.2.判断v是否已访问，已访问则跳过
            if not visited[v]:
                # 2.3.标记v为已访问，并根据条件判断是否能匹配，能匹配的情况下记录右结点v的匹配状态到rightMatch中
                visited[v] = True
                if v not in rightMatch or dfs(rightMatch[v]):
                    rightMatch[v] = u
                    return True
        # 2.4.如果最终都没能匹配一个，则返回False
        return False
    # 第三步，枚举每一个左集合结点u，调用dfs判断各个u结点是否能成功进行匹配，并记录最大匹配数到ans中
    ans = 0
    for u in leftNodes:
        visited = defaultdict(bool)
        if dfs(u):
            ans += 1
    return ans


class Solution:
    def getGraphAndNodes(self, grid: List[List[int]]):
        m, n = len(grid), len(grid[0])
        # 第一步，构建二分图。在所有值为1的结点中，其中偶数下标行的偶数下标结点和奇数下标行的奇数下标结点为左结点集合uSet，其余结点为右结点集合vSet；uSet和vSet中彼此相邻代表一条边
        graph = defaultdict(list)
        leftNodes, rightNodes = [], []
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    # 1.1.将结点添加到图中
                    node = i * n + j
                    if (i % 2 == 0 and j % 2 == 0) or (i % 2 == 1 and j % 2 == 1):
                        leftNodes.append(node)
                    else:
                        rightNodes.append(node)
                    graph[node] = []
                    # 1.2.将边添加到图中
                    for dr, dc in [[-1, 0], [0, -1], [1, 0], [0, 1]]:
                        nr, nc = i + dr, j + dc
                        if 0 <= nr < m and 0 <= nc < n and grid[nr][nc] == 1:
                            node2 = nr * n + nc
                            graph[node].append(node2)
        # print(graph)
        return graph, leftNodes, rightNodes

    # 思路1【超时】：二分图+匈牙利算法。题目转换：等价于求二分图的最大匹配数
    def minimumOperations(self, grid: List[List[int]]) -> int:
        graph, leftNodes, _ = self.getGraphAndNodes(grid)
        # 第二步，执行匈牙利算法获取最大匹配数
        return hungarian(graph, leftNodes)

二分图+Hopcroft-karp算法代码