Sum in a Matrix

Sum in a Matrix - Problem

You are given a 0-indexed 2D integer array nums. Initially, your score is 0. Perform the following operations until the matrix becomes empty:

1. From each row in the matrix, select the largest number and remove it. In the case of a tie, it does not matter which number is chosen.

2. Identify the highest number amongst all those removed in step 1. Add that number to your score.

Return the final score.

Input & Output

Example 1 — Basic Matrix

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

› Output: 25

💡 Note: Round 1: Remove max from each row [9,6,1], score += max(9,6,1) = 9. Round 2: Remove [8,1], score += max(8,1) = 8, total = 17. Round 3: Remove [7], score += 7, total = 24. Round 4: Remove [6], score += 6, total = 30. Round 5: Remove [2], score += 2, total = 32.

Example 2 — Single Row

$ Input: nums = [[1]]

› Output: 1

💡 Note: Only one element in the matrix. Remove 1, add to score. Final score = 1.

Example 3 — Multiple Equal Elements

$ Input: nums = [[1,2,3],[1,2,3],[1,2,3]]

› Output: 6

💡 Note: Round 1: Remove [3,3,3], max=3, score=3. Round 2: Remove [2,2,2], max=2, score=5. Round 3: Remove [1,1,1], max=1, score=6. Total = 6.

Constraints

1 ≤ nums.length ≤ 50
1 ≤ nums[i].length ≤ 50
1 ≤ nums[i][j] ≤ 10³

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is to efficiently extract maximum elements from each row repeatedly. The optimal approach uses sorting each row first then processing column-wise, achieving O(nm log m) time. Space complexity is O(1) with in-place modifications.

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n²m²) Space: O(1)

For each round, scan through every row to find the maximum element, remove it, then find the maximum among all removed elements. Continue until matrix is empty.

Priority Queue Optimization

⏱️ Time: O(nm log m) Space: O(1)

Convert each row into a max heap. In each round, extract the maximum from each heap, find the overall maximum, and add to score. This eliminates repeated searching.

Sort Each Row First

⏱️ Time: O(nm log m + nm²) Space: O(1)

Pre-sort each row in descending order so that the maximum element is always at the front. Then simulate the process by taking the first element from each non-empty row.

Brute Force Simulation — Algorithm Steps

While matrix has elements, find max in each row
Remove these maximums and store in temporary array
Find maximum of removed elements and add to score

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Row Maximums

Scan each row to find largest element

Remove and Compare

Remove maximums and find overall maximum

Add to Score

Add round maximum to running score

Code -

solution.c — C

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

static int nums[60][60];
static int numsColSize[60];
static int numsSize;

int solution() {
    int score = 0;
    
    while (1) {
        int hasElements = 0;
        int roundMax = INT_MIN;
        
        for (int i = 0; i < numsSize; i++) {
            if (numsColSize[i] > 0) {
                hasElements = 1;
                int rowMax = nums[i][0];
                int maxIdx = 0;
                
                for (int j = 1; j < numsColSize[i]; j++) {
                    if (nums[i][j] > rowMax) {
                        rowMax = nums[i][j];
                        maxIdx = j;
                    }
                }
                
                for (int j = maxIdx; j < numsColSize[i] - 1; j++) {
                    nums[i][j] = nums[i][j + 1];
                }
                numsColSize[i]--;
                
                if (rowMax > roundMax) {
                    roundMax = rowMax;
                }
            }
        }
        
        if (!hasElements) break;
        score += roundMax;
    }
    
    return score;
}

void parseMatrix(char* line) {
    numsSize = 0;
    int len = strlen(line);
    int i = 1; // skip first '['
    
    while (i < len - 1) { // skip last ']'
        if (line[i] == '[') {
            i++; // skip '['
            numsColSize[numsSize] = 0;
            char num[20] = "";
            int numIdx = 0;
            
            while (i < len && line[i] != ']') {
                if (line[i] == ',' || line[i] == ']') {
                    if (numIdx > 0) {
                        num[numIdx] = '\0';
                        nums[numsSize][numsColSize[numsSize]] = strtol(num, NULL, 10);
                        numsColSize[numsSize]++;
                        numIdx = 0;
                    }
                } else if (line[i] != ' ') {
                    num[numIdx++] = line[i];
                }
                i++;
            }
            if (numIdx > 0) {
                num[numIdx] = '\0';
                nums[numsSize][numsColSize[numsSize]] = strtol(num, NULL, 10);
                numsColSize[numsSize]++;
            }
            numsSize++;
            i++; // skip ']'
        } else {
            i++;
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    int len = strlen(line);
    if (line[len-1] == '\n') line[len-1] = '\0';
    
    parseMatrix(line);
    printf("%d\n", solution());
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²m²)

For each of m columns, we scan n rows to find max, repeated m times

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for tracking, modifying input in-place

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

445 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler