LeetCode 1878.矩阵中最大的三个菱形和：斜向前缀和

【LetMeFly】1878.矩阵中最大的三个菱形和：斜向前缀和

力扣题目链接：https://leetcode.cn/problems/get-biggest-three-rhombus-sums-in-a-grid/

给你一个 m x n 的整数矩阵 grid 。

菱形和 指的是 grid 中一个正菱形边界上的元素之和。本题中的菱形必须为正方形旋转45度，且四个角都在一个格子当中。下图是四个可行的菱形，每个菱形和应该包含的格子都用了相应颜色标注在图中。

注意，菱形可以是一个面积为 0 的区域，如上图中右下角的紫色菱形所示。

请你按照降序返回 grid 中三个最大的 互不相同的菱形和 。如果不同的和少于三个，则将它们全部返回。

示例 1：

复制代码

输入：grid = [[3,4,5,1,3],[3,3,4,2,3],[20,30,200,40,10],[1,5,5,4,1],[4,3,2,2,5]]
输出：[228,216,211]
解释：最大的三个菱形和如上图所示。
- 蓝色：20 + 3 + 200 + 5 = 228
- 红色：200 + 2 + 10 + 4 = 216
- 绿色：5 + 200 + 4 + 2 = 211

示例 2：

复制代码

输入：grid = [[1,2,3],[4,5,6],[7,8,9]]
输出：[20,9,8]
解释：最大的三个菱形和如上图所示。
- 蓝色：4 + 2 + 6 + 8 = 20
- 红色：9 （右下角红色的面积为 0 的菱形）
- 绿色：8 （下方中央面积为 0 的菱形）

示例 3：

复制代码

输入：grid = [[7,7,7]]
输出：[7]
解释：所有三个可能的菱形和都相同，所以返回 [7] 。

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 100
1 <= grid[i][j] <= 10⁵

解题方法：斜向前缀和

严格按照以下约定计算和使用前缀和：

↘ (i, j) -> (x, y): d i a g [ x + 1 ] [ y + 1 ] − d i a g [ i ] [ j ] diag[x+1][y+1] - diag[i][j] diag[x+1][y+1]−diag[i][j]
↗ (i, j) -> (x, y): a n t i [ i + 1 ] [ j ] − a n t i [ x ] [ y + 1 ] anti[i+1][j] - anti[x][y+1] anti[i+1][j]−anti[x][y+1]

遍历一遍原始数组我们即可得到前缀和数组。

然后枚举每个菱形的中心和菱形的二分之一对角线长度 k k k，依据前缀和计算4条边的长度，三个变量维护三个最大的不同周长。

时间复杂度 O ( n m min ⁡ ( m , n ) ) O(nm\min(m,n)) O(nmmin(m,n))
空间复杂度 O ( m n ) O(mn) O(mn)

AC代码

C++

cpp 复制代码

/*
 * @LastEditTime: 2026-03-17 00:04:02
 */
/*
↘ (i, j) -> (x, y): diag[x+1][y+1] - diag[i][j]
↗ (i, j) -> (x, y): anti[i+1][j] - anti[x][y+1]
*/
class Solution {
private:
    int x = 0, y = 0, z = 0;  // 三大
    vector<vector<int>> diag, anti;

    void update(int v) {
        if (v > x) {
            z = y, y = x, x = v;
        } else if (v < x && v > y) {
            z = y, y = v;
        } else if (v < y && v > z) {
            z = v;
        }
    }

    void calc(int i, int j, int k) {
        if (!k) {
            return update(diag[i + 1][j + 1] - diag[i][j]);
        }
        // 上：i - k, j
        // 下：i + k, j
        // 左：i, j - k
        // 右：i, j + k
        int val = 0
            + diag[i][j + k] - diag[i - k][j]                  // ↘ [上, 右)：(i-k, j)->(i, j+k) | (i-k,j)->(i-1, j+k-1)
            + diag[i + k + 1][j + 1] - diag[i + 1][j - k + 1]  // ↘ (左, 下]：(i,j-k)->(i+k,j) | (i+1,j-k+1)->(i+k,j)
            + anti[i + 1][j - k] - anti[i - k + 1][j]          // ↗ [左, 上)：(i,j-k)->(i-k,j) | (i,j-k)->(i-k+1,j-1)
            + anti[i + k][j + 1] - anti[i][j + k + 1];         // ↗ (下, 右]：(i+k,j)->(i,j+k) | (i+k-1,j+1)->(i,j+k)
        update(val);
    }
public:
    vector<int> getBiggestThree(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        diag = vector<vector<int>>(n + 1, vector<int>(m + 1));  // ↘
        anti = vector<vector<int>>(n + 1, vector<int>(m + 1));  // ↖
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                diag[i + 1][j + 1] = diag[i][j] + grid[i][j];
                anti[i + 1][j] = anti[i][j + 1] + grid[i][j];
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                for (int k = 0, max_k = min(i, min(j, min(n - i - 1, m - j - 1))); k <= max_k; k++) {
                    calc(i, j, k);
                }
            }
        }

        vector<int> ans;
        if (x) {
            ans.push_back(x);
        }
        if (y) {
            ans.push_back(y);
        }
        if (z) {
            ans.push_back(z);
        }
        return ans;
    }
};

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

千篇源码题解已开源