Sum in a Matrix solution and explanation

def matrix_sum(nums):
    score = 0
    while any(nums):
        # Select the largest number from each row and remove it
        max_in_rows = [max(row) for row in nums]
        for row in nums:
            if row:
                row.remove(max(row))
        # Add the maximum of these numbers to the score
        score += max(max_in_rows)
    return score

nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]]
result = matrix_sum(nums)
print(result)  # Output: 15

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int matrixSum(vector<vector<int>>& nums) {
    int score = 0;
    while (!nums.empty()) {
        // Select and remove the largest number from each row
        vector<int> max_in_rows;
        for (auto &row : nums) {
            if (!row.empty()) {
                auto it = max_element(row.begin(), row.end());
                max_in_rows.push_back(*it);
                row.erase(it);
            }
        }
        // Store only non-empty rows
        nums.erase(remove_if(nums.begin(), nums.end(), [](vector<int>& v) { return v.empty(); }), nums.end());
        // Add the maximum of these numbers to the score
        if (!max_in_rows.empty()) score += *max_element(max_in_rows.begin(), max_in_rows.end());
    }
    return score;
}

int main() {
    vector<vector<int>> nums = {{7,2,1},{6,4,2},{6,5,3},{3,2,1}};
    cout << matrixSum(nums) << endl; // Output: 15
    return 0;
}

import java.util.PriorityQueue;

public class MatrixSum {
    public int matrixSum(int[][] nums) {
        int score = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>( (a, b) -> b - a );
        int n = nums.length;
        int m = nums[0].length;

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                pq.add(nums[i][j]);
            }
        }

        while (!pq.isEmpty()) {
            int maxVal = pq.poll();
            score += maxVal;
            m--;
            if (m == 0) break;
            for (int i = 0; i < n; ++i) {
                Integer max_elem = nums[i].length > 0 ? pq.remove(nums[i].length - 1) : null;
                if (max_elem != null) pq.add(max_elem);
            }
        }
        return score;
    }

    public static void main(String[] args) {
        int[][] nums = {{7,2,1},{6,4,2},{6,5,3},{3,2,1}};
        MatrixSum ms = new MatrixSum();
        System.out.println(ms.matrixSum(nums)); // Output: 15
    }
}

function matrixSum(nums) {
    let score = 0;
    let pq = [];

    nums.forEach(row => row.forEach(num => pq.push(num)));

    pq.sort((a, b) => b - a);

    let m = nums[0].length;
    while (pq.length) {
        score += pq.shift();
        m--;
        if (m === 0) break;

        nums.forEach(row => {
            if (row.length > 0) {
                pq.push(row.shift());
            }
        });
        pq.sort((a, b) => b - a);
    }
    return score;
}

console.log(matrixSum([[7,2,1],[6,4,2],[6,5,3],[3,2,1]])); // Output: 15

function matrixSum(nums: number[][]): number {
    for (const row of nums) {
        row.sort((a, b) => a - b);
    }
    let ans = 0;
    for (let j = 0; j < nums[0].length; ++j) {
        let mx = 0;
        for (const row of nums) {
            mx = Math.max(mx, row[j]);
        }
        ans += mx;
    }
    return ans;
}

func matrixSum(nums [][]int) (ans int) {
	for _, row := range nums {
		sort.Ints(row)
	}
	for i := 0; i < len(nums[0]); i++ {
		mx := 0
		for _, row := range nums {
			mx = max(mx, row[i])
		}
		ans += mx
	}
	return
}

impl Solution {
    pub fn matrix_sum(mut nums: Vec<Vec<i32>>) -> i32 {
        for row in &mut nums {
            row.sort();
        }
        (0..nums[0].len())
            .map(|col| nums.iter().map(|row| row[col]).max().unwrap())
            .sum()
    }
}