835_image_overlap

835. 图像重叠 中等

给你两个图像 img1 和 img2 ，两个图像的大小都是 n x n ，用大小相同的二维正方形矩阵表示。（并且为二进制矩阵，只包含若干 0 和若干 1 ）

转换其中一个图像，向左，右，上，或下滑动任何数量的单位，并把它放在另一个图像的上面。之后，该转换的 重叠 是指两个图像都具有 1 的位置的数目。

（请注意，转换 不包括 向任何方向旋转。）

最大可能的重叠是多少？

示例 1：

输入：img1 = [[1,1,0],[0,1,0],[0,1,0]], img2 = [[0,0,0],[0,1,1],[0,0,1]]
输出：3
解释：将 img1 向右移动 1 个单位，再向下移动 1 个单位。

两个图像都具有 1 的位置的数目是 3（用红色标识）。

示例 2：

输入：img1 = [[1]], img2 = [[1]]
输出：1

示例 3：

输入：img1 = [[0]], img2 = [[0]]
输出：0

提示：

• n == img1.length
• n == img1[i].length
• n == img2.length
• n == img2[i].length
• 1 <= n <= 30
• img1[i][j] 为 0 或 1
• img2[i][j] 为 0 或 1

代码参考：

package main

import "fmt"

func main() {
    a := [][]int{
        {1, 1, 0},
        {0, 1, 0},
        {0, 1, 0},
    }
    b := [][]int{
        {0, 0, 0},
        {0, 1, 1},
        {0, 0, 1},
    }
    fmt.Println(largestOverlap(a, b)) // 3
}

// n <= 30，暴力遍历可接受
func largestOverlap(A [][]int, B [][]int) int {
    max := 0
    n := len(A)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j ++ {

            countA, countB := 0, 0
            for r := i; r < n; r++ {
                for c := j; c < n; c++ {

                    preR, preC := r-i, c-j
                    if A[r][c] == 1 && B[preR][preC] == 1 { // 重复且为 1 的位置计数
                        countA += 1
                    }
                    if B[r][c] == 1 && A[preR][preC] == 1 {
                        countB += 1
                    }
                }
            }

            if countA > max {
                max = countA
            }
            if countB > max {
                max = countB
            }
        }
    }
    return max
}