Sum in a Matrix - Practice Coding Problems

Sum in a Matrix - Problem

Imagine you're playing a strategic game with a matrix of numbers! 🎯

You are given a 0-indexed 2D integer array nums. Your task is to repeatedly perform operations until the matrix becomes empty, accumulating a score along the way.

Here's how the game works:

Selection Phase: From each row in the matrix, select and remove the largest number. If there's a tie, you can pick any of the tied numbers.
Scoring Phase: Among all the numbers you just removed, find the highest one and add it to your score.
Repeat: Continue until the matrix is completely empty.

Goal: Return the final accumulated score after all operations.

Example: If you have [[7,2,1],[6,4,2],[6,5,3,3]], in the first round you'd remove [7,6,6] and add max(7,6,6) = 7 to your score!

Input & Output

example_1.py — Basic Case

$ Input: nums = [[7,2,1],[6,4,2],[6,5,3,3]]

› Output: 15

💡 Note: Round 1: Remove max from each row: [7,6,6], winner = 7. Round 2: Remove max from remaining: [2,4,5], winner = 5. Round 3: Remove max: [1,2,3], winner = 3. Round 4: Only one element left: [3], winner = 3. But wait - the third row has 4 elements initially, so Round 4 has winner = 3. Total: 7 + 5 + 3 + 3 = 15.

example_2.py — Simple Case

$ Input: nums = [[1]]

› Output: 1

💡 Note: Only one element in the matrix, so the score is just that element: 1.

example_3.py — Uniform Rows

$ Input: nums = [[1,2,3],[4,5,6],[7,8,9]]

› Output: 24

💡 Note: Round 1: max(3,6,9) = 9. Round 2: max(2,5,8) = 8. Round 3: max(1,4,7) = 7. Total: 9 + 8 + 7 = 24.

Visualization

Tap to expand

Understanding the Visualization

Team Preparation

Each team sorts their players by skill level (descending order)

Round 1

Each team sends their strongest player - find the tournament winner

Round 2

Each team sends their next strongest player - find the winner

Continue

Repeat until all players have competed

Final Score

Sum up all the round winners' skill levels

Key Takeaway

🎯 Key Insight: Pre-sorting each row transforms expensive repeated searches into constant-time array accesses, dramatically improving performance from quadratic to linearithmic time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(m × n log n)

Sorting each of the m rows takes O(n log n) time, and then processing takes O(m × n) time, so total is O(m × n log n)

⚡ Linearithmic

Space Complexity

O(1)

Sorting is done in-place, and we only use constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i].length ≤ 50
1 ≤ nums[i][j] ≤ 10³
Matrix rows can have different lengths

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach is to sort each row in descending order first, then process the matrix column by column. Each column represents a round where we find the maximum element among all rows' current positions. This eliminates the need to repeatedly search for maximum elements, reducing time complexity from O(m² × n²) to O(m × n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Sorting Approach	O(m × n log n)	O(1)	Sort each row in descending order, then process columns from left to right

Optimized Sorting Approach — Algorithm Steps

Sort each row in descending order
Initialize score to 0
For each column position (round):
Collect the element at current position from each row (if exists)
Find the maximum among collected elements
Add this maximum to the score
Return the final score

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Rows

Sort each row in descending order

Process Columns

Process each column as a round

Find Column Max

Maximum of each column is the round winner

Accumulate Score

Sum all column maximums

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Comparison function for qsort (descending order)
int compare(const void* a, const void* b) {
    return (*(int*)b - *(int*)a);
}

int matrixSum(int** nums, int numsSize, int* numsColSize) {
    // Sort each row in descending order
    for (int i = 0; i < numsSize; i++) {
        qsort(nums[i], numsColSize[i], sizeof(int), compare);
    }
    
    int score = 0;
    int maxCols = 0;
    
    // Find maximum column size
    for (int i = 0; i < numsSize; i++) {
        if (numsColSize[i] > maxCols) {
            maxCols = numsColSize[i];
        }
    }
    
    // Process each column (round)
    for (int col = 0; col < maxCols; col++) {
        int roundMax = 0;
        for (int row = 0; row < numsSize; row++) {
            if (col < numsColSize[row]) {
                if (nums[row][col] > roundMax) {
                    roundMax = nums[row][col];
                }
            }
        }
        score += roundMax;
    }
    
    return score;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n log n)

Sorting each of the m rows takes O(n log n) time, and then processing takes O(m × n) time, so total is O(m × n log n)

⚡ Linearithmic

Space Complexity

O(1)

Sorting is done in-place, and we only use constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i].length ≤ 50
1 ≤ nums[i][j] ≤ 10³
Matrix rows can have different lengths

28.2K Views

Medium Frequency

~12 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Sorting Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler