通过翻转大小为 K 的子矩阵将二进制矩阵 A 转换为 B 的最小操作

介绍

给定两个大小为 (m x n) 的二进制矩阵 A 和 B，我们需要通过一系列翻转大小为 K x K 的子矩阵的操作，将矩阵 A 转换成矩阵 B。

每个子矩阵的翻转被定义为将 0 变为 1，或者将 1 变为 0。翻转操作可以被应用多次，并且可以被应用于同一个子矩阵。我们的目标是找到一系列最小的操作，使得 A 变成 B。若不能将 A 转换为 B，则返回 -1。

解法

一种可行的解法是贪心算法，根据题目要求，对于一个二进制矩阵 A，我们可以通过翻转大小为 K x K 的子矩阵来进行变换。因此，我们可以考虑从每一个矩阵位置 (i, j) 开始，用宽度为 K 的滑动窗口（即子矩阵）扫描 A 和 B 对应位置，统计该窗口中矩阵 A 和 B 对应位置每个数位的出现次数。如果在统计的过程中，A 和 B 对应位置的数位出现次数不一致，则说明这个子矩阵是无法通过一系列翻转操作变换 A 成 B 的。

为了最小化操作次数，我们可以将统计的过程和翻转的过程合并，对于无法变换的子矩阵，我们直接跳过；对于可以变换的子矩阵，我们将其中出现次数少的数位翻转，直到两个子矩阵相等。

具体实现时，我们可以使用哈希表来维护窗口中数位出现次数的信息，使用滑动窗口技巧来快速统计。在统计完所有的子矩阵后，如果 A 变换成了 B，则返回操作次数，否则返回 -1。

代码

以下为 Python 代码实现，时间复杂度为 O(mnk)，其中 m 和 n 为矩阵的大小，k 为子矩阵的大小。代码中用到了 Python 标准库 collections 中的 Counter 子类，用于统计窗口中数字的出现次数。

from typing import List
from collections import Counter


def minFlips(mat: List[List[int]], target: List[List[int]]) -> int:
    m, n, ans = len(mat), len(mat[0]), 0
    for i in range(m - 2 * len(target) + 1):
        for j in range(n - 2 * len(target[0]) + 1):
            cnt1, cnt2 = Counter(), Counter()
            for r in range(i, i + len(target)):
                for c in range(j, j + len(target[0])):
                    cnt1[str(mat[r][c])] += 1
                    cnt2[str(target[r - i][c - j])] += 1
            if cnt1 == cnt2:
                continue
            for r in range(i, i + len(target)):
                for c in range(j, j + len(target[0])):
                    if cnt1['1'] < cnt2['1']:
                        mat[r][c] = 1 - mat[r][c]
                    if cnt1['0'] < cnt2['0']:
                        mat[r][c] = 1 - mat[r][c]
            if cnt1 != cnt2:
                return -1
            ans += sum(mat, []).count(1)
    return ans

这里使用 sum 函数，将二维矩阵展开成一维列表来统计矩阵中 1 的个数。