LeetCode 1878. 矩阵中最大的三个菱形和（模拟）_菱形和指的是一个正菱形边界上元素之和-CSDN博客

本文链接：https://blog.csdn.net/qq_21201267/article/details/117393155

文章目录

- 1. 题目
- 2. 解题

1. 题目

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

https://leetcode-cn.com/contest/biweekly-contest-53/problems/get-biggest-three-rhombus-sums-in-a-grid/
https://leetcode-cn.com/problems/get-biggest-three-rhombus-sums-in-a-grid/

2. 解题

不要害怕，就是暴力模拟

class Solution {
public:
    vector<int> getBiggestThree(vector<vector<int>>& g) {
        int m = g.size(), n = g[0].size();
        set<int> res;
        vector<vector<int>> dir  ={{1,-1},{1,1},{-1,1},{-1,-1}};
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {  // (i, j) 为中心
                res.insert(g[i][j]);
                for(int len = 1; len <= max(m,n); len++)
                {
                    if(i+len>=m || i-len<0 || j+len >= n || j-len < 0)
                        break;
                    int x = i-len, y = j; // 最高点开始
                    int sum = 0;
                    for(int k = 0; k < 4; k++) // 4条边
                    {
                        int step = len;//每边走len步
                        while(step--)
                        {
                            x += dir[k][0];
                            y += dir[k][1];
                            sum += g[x][y];
                        }
                    }
                    res.insert(sum);
                }
            }
        }
        vector<int> ans;
        while(res.size() && ans.size() < 3)
        {  	// 取出最大的3个
            auto it = res.end();
            it--;
            ans.push_back(*it);
            res.erase(it);
        }
        return ans;
    }
};