2500-删除每行中的最大值

给你一个 m x n 大小的矩阵 grid ，由若干正整数组成。

执行下述操作，直到 grid 变为空矩阵：

• 从每一行删除值最大的元素。如果存在多个这样的值，删除其中任何一个。
• 将删除元素中的最大值与答案相加。

注意 每执行一次操作，矩阵中列的数据就会减 1 。

返回执行上述操作后的答案。

示例 1：

**输入：** grid = [[1,2,4],[3,3,1]]
**输出：** 8
**解释：** 上图展示在每一步中需要移除的值。
- 在第一步操作中，从第一行删除 4 ，从第二行删除 3（注意，有两个单元格中的值为 3 ，我们可以删除任一）。在答案上加 4 。
- 在第二步操作中，从第一行删除 2 ，从第二行删除 3 。在答案上加 3 。
- 在第三步操作中，从第一行删除 1 ，从第二行删除 1 。在答案上加 1 。
最终，答案 = 4 + 3 + 1 = 8 。

示例 2：

**输入：** grid = [[10]]
**输出：** 10
**解释：** 上图展示在每一步中需要移除的值。
- 在第一步操作中，从第一行删除 10 。在答案上加 10 。
最终，答案 = 10 。

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 50
• 1 <= grid[i][j] <= 100

方法一：排序

思路与算法

我们将题目给出大小为 m \times n 的矩阵 grid 每一行从小到大排序，那么题目等价于每次删除矩阵的末尾列，得分为该列的最大值。那么最后的答案就是每一列的最大值之和。

代码

[sol1-Python3]

class Solution:
    def deleteGreatestValue(self, grid: List[List[int]]) -> int:
        for i in grid:
            i.sort()
        return sum([max(i) for i in zip(*grid)])

[sol1-Java]

class Solution {
    public int deleteGreatestValue(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        for (int i = 0; i < m; i++) {
            Arrays.sort(grid[i]);
        }
        int res = 0;
        for (int j = 0; j < n; j++) {
            int mx = 0;
            for (int i = 0; i < m; i++) {
                mx = Math.max(mx, grid[i][j]);
            }
            res += mx;
        }
        return res;
    }
}

[sol1-C++]

class Solution {
public:
    int deleteGreatestValue(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        for (int i = 0; i < m; i++) {
            sort(grid[i].begin(), grid[i].end());
        }
        int res = 0;
        for (int j = 0; j < n; j++) {
            int mx = 0;
            for (int i = 0; i < m; i++) {
                mx = max(mx, grid[i][j]);
            }
            res += mx;
        }
        return res;
    }
};

[sol1-C#]

public class Solution {
    public int DeleteGreatestValue(int[][] grid) {
        int m = grid.Length, n = grid[0].Length;
        for (int i = 0; i < m; i++) {
            Array.Sort(grid[i]);
        }
        int res = 0;
        for (int j = 0; j < n; j++) {
            int mx = 0;
            for (int i = 0; i < m; i++) {
                mx = Math.Max(mx, grid[i][j]);
            }
            res += mx;
        }
        return res;
    }
}

[sol1-Go]

func deleteGreatestValue(grid [][]int) int {
    m := len(grid)
    n := len(grid[0])
    for i := 0; i < m; i++ {
        sort.Ints(grid[i])
    }
    res := 0
    for j := 0; j < n; j++ {
        mx := 0
        for i := 0; i < m; i++ {
            mx = max(mx, grid[i][j])
        }
        res += mx
    }
    return res
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

[sol1-JavaScript]

var deleteGreatestValue = function(grid) {
    const m = grid.length, n = grid[0].length;
    for (let i = 0; i < m; i++) {
        grid[i].sort((a, b) => a - b);
    }
    let res = 0;
    for (let j = 0; j < n; j++) {
        let mx = 0;
        for (let i = 0; i < m; i++) {
            mx = Math.max(mx, grid[i][j]);
        }
        res += mx;
    }
    return res;
};

[sol1-C]

int cmp(void const* a, void const* b) {
    return *(int*)a - *(int*)b;
}

int deleteGreatestValue(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = *gridColSize;
    for (int i = 0; i < m; ++i) {
        qsort(grid[i], n, 4U, cmp);
    }
    int res = 0;
    for (int j = 0; j < n; j++) {
        int mx = 0;
        for (int i = 0; i < m; ++i) {
            if (grid[i][j] > mx) {
                mx = grid[i][j];
            }
        }
        res += mx;
    }
    return res;
}

复杂度分析

• 时间复杂度：O(m \times n \times \log n)，其中 m，n 分别为矩阵 grid 的行列数，对矩阵 grid 的每一行排序的时间复杂度为 n \times \log n，共有 m 行，所以总的时间复杂度为 O(m \times n \times \log n)。
• 空间复杂度：O(\log n)，排序需要的栈开销。