leetcode 1878. 矩阵中最大的三个菱形和 中等

给你一个 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^5

分析：枚举每一个点能够组成的所有菱形，将最大的三个不同的和作为答案返回。为了加快求和速度，可以先预处理出每一个点向右下和向左下的边的和。

class Solution {
public:
    vector<int> getBiggestThree(vector<vector<int>>& grid) {
        int m=grid.size(),n=grid[0].size(),len=min(m,n);
        int right_left[m+5][n+5],left_right[m+5][n+5];
        vector<int>ans;
        for(int i=0;i<m;++i)
        {
            for(int j=0;j<n;++j)
            {
                ans.push_back(grid[i][j]);
                right_left[i][j]=left_right[i][j]=0;
                for(int k=j,l=i;k>=0&&l<m;--k,++l)
                    right_left[i][j]+=grid[l][k];
                for(int k=i,l=j;k<m&&l<n;++k,++l)
                    left_right[i][j]+=grid[k][l];
            }
        }
        
        for(int i=0;i<m;++i)
        {
            for(int j=0;j<n;++j)
            {
                for(int l=1;l<len;++l)
                {
                    if(i+l>=m||j+l>=n||j-l<0||i+2*l>=m)break;
                    int sum=0;
                    sum+=left_right[i][j]-left_right[i+l][j+l]+grid[i+l][j+l];
                    sum+=left_right[i+l][j-l]-left_right[i+2*l][j]+grid[i+2*l][j];
                    sum+=right_left[i][j]-right_left[i+l][j-l]-grid[i][j];
                    sum+=right_left[i+l][j+l]-right_left[i+2*l][j]-grid[i+l][j+l];
                    ans.push_back(sum);
                }
            }
        }
        sort(ans.begin(),ans.end());
        vector<int>ret;
        ret.push_back(ans[ans.size()-1]);
        for(int i=ans.size()-1;i>=0&&ret.size()<3;--i)
            if(ans[i]!=ret[ret.size()-1])ret.push_back(ans[i]);
        return ret;
    }
};