一【题目类别】

矩阵

二【题目难度】

中等

三【题目编号】

1572.矩阵对角线元素的和

四【题目描述】

给你一座由 n x n 个街区组成的城市，每个街区都包含一座立方体建筑。给你一个下标从 0 开始的 n x n 整数矩阵 grid ，其中 grid[r][c] 表示坐落于 r 行 c 列的建筑物的高度。
城市的天际线是从远处观察城市时，所有建筑物形成的外部轮廓。从东、南、西、北四个主要方向观测到的天际线可能不同。
我们被允许为任意数量的建筑物的高度增加任意增量（不同建筑物的增量可能不同）。高度为 0 的建筑物的高度也可以增加。然而，增加的建筑物高度不能影响从任何主要方向观察城市得到的天际线。
在不改变从任何主要方向观测到的城市天际线的前提下，返回建筑物可以增加的最大高度增量总和。

五【题目示例】

示例 1：
- 输入：grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
- 输出：35
- 解释：建筑物的高度如上图中心所示。用红色绘制从不同方向观看得到的天际线。在不影响天际线的情况下，增加建筑物的高度：gridNew = [ [8, 4, 8, 7],
                                       [7, 4, 7, 7],
                                       [9, 4, 8, 7],
                                       [3, 3, 3, 3] ]
示例 2：
- 输入：grid = [[0,0,0],[0,0,0],[0,0,0]]
- 输出：0
- 解释：增加任何建筑物的高度都会导致天际线的变化。

六【题目提示】

$n == g r i d . l e n g t h$
$n == g r i d [r] . l e n g t h$
$2 <= n <= 50$
$0 <= g r i d [r] [c] <= 100$

七【解题思路】

这道题主要是要理解题意，这道题的意思是找出每一行和每一列的最大值，然后看每一个元素增加多少高度不会超过当前这个元素所处行和列最大值中的最小值，这样就不会破坏每个方向观测到的“天际线”
所以我们就遍历整个二维数组，找到每一行和每一列的最大值
然后计算当前元素增加多少高度不会超过当前这个元素所处行和列最大值中的最小值
对二维矩阵中的每个元素都进行上面的操作，然后求和
最后返回结果即可

八【时间频度】

时间复杂度： $O(n^2)$ ， $n$ 为传入的正方形数组的长度
空间复杂度： $O (n)$ ， $n$ 为传入的正方形数组的长度

九【代码实现】

Java语言版

class Solution {
    
    
    public int maxIncreaseKeepingSkyline(int[][] grid) {
    
    
        int n = grid.length;
        int res = 0;
        int[] rawMax = new int[n];
        int[] colMax = new int[n];
        for(int i = 0;i < n;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                rawMax[i] = Math.max(rawMax[i],grid[i][j]);
                colMax[j] = Math.max(colMax[j],grid[i][j]);
            }
        }
        for(int i = 0;i < n;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                res += Math.min((rawMax[i] - grid[i][j]),(colMax[j] - grid[i][j]));
            }
        }
        return res;
    }
}

C语言版

int maxIncreaseKeepingSkyline(int** grid, int gridSize, int* gridColSize)
{
    
    
    int n = gridSize;
    int res = 0;
    int* rawMax = (int*)calloc(n, sizeof(int));
    int* colMax = (int*)calloc(n, sizeof(int));
    for(int i = 0;i < n;i++)
    {
    
    
        for(int j = 0;j < n;j++)
        {
    
    
            rawMax[i] = fmax(rawMax[i], grid[i][j]);
            colMax[j] = fmax(colMax[j], grid[i][j]);
        }
    }
    for(int i = 0;i < n;i++)
    {
    
    
        for(int j = 0;j < n;j++)
        {
    
    
            res += fmin(rawMax[i] - grid[i][j], colMax[j] - grid[i][j]);
        }
    }
    return res;
}

Python语言版

class Solution:
    def maxIncreaseKeepingSkyline(self, grid: List[List[int]]) -> int:
        n = len(grid)
        res = 0
        rawMax = [0] * n
        colMax = [0] * n
        for i in range(0, n):
            for j in range(0, n):
                rawMax[i] = max(rawMax[i],grid[i][j])
                colMax[j] = max(colMax[j],grid[i][j])
        for i in range(0, n):
            for j in range(0, n):
                res += min(rawMax[i] - grid[i][j], colMax[j] - grid[i][j])
        return res

C++语言版

class Solution {
    
    
public:
    int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {
    
    
        int n = grid.size();
        int res = 0;
        vector<int> rawMax(n);
        vector<int> colMax(n);
        for(int i = 0;i < n;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                rawMax[i] = fmax(rawMax[i],grid[i][j]);
                colMax[j] = fmax(colMax[j],grid[i][j]);
            }
        }
        for(int i = 0;i < n;i++){
    
    
            for(int j = 0;j < n;j++){
    
    
                res += fmin(rawMax[i] - grid[i][j],colMax[j] - grid[i][j]);
            }
        }
        return res;
    }
};