Delete Greatest Value in Each Row - Practice Coding Problems

Delete Greatest Value in Each Row - Problem

You're given an m x n matrix grid filled with positive integers. Your task is to perform a series of operations that simulate a competitive elimination process!

The Process:

In each round, find and delete the greatest value from every row simultaneously
Among all the deleted values, find the maximum and add it to your answer
Repeat until the matrix becomes completely empty

Think of it like a tournament where each row represents a team, and in each round, each team eliminates their strongest player. The strongest among all eliminated players contributes to the final score!

Note: If multiple elements in a row have the same maximum value, you can delete any of them. The number of columns decreases by one after each operation.

Input & Output

example_1.py — Basic Matrix

$ Input: grid = [[1,2,4],[3,3,1]]

› Output: 8

💡 Note: Round 1: Remove max from each row [4,3], add max(4,3)=4. Round 2: Remove max from remaining [2,3], add max(2,3)=3. Round 3: Remove max from remaining [1,1], add max(1,1)=1. Total: 4+3+1=8

example_2.py — Single Element

$ Input: grid = [[10]]

› Output: 10

💡 Note: Only one element in the matrix, so we remove 10 and add it to result. Total: 10

example_3.py — Equal Elements

$ Input: grid = [[5,5,5],[5,5,5]]

› Output: 15

💡 Note: All elements are equal. Round 1: Remove [5,5], add 5. Round 2: Remove [5,5], add 5. Round 3: Remove [5,5], add 5. Total: 5+5+5=15

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Team Rosters

Each team has players with different skill levels (matrix values)

Sort Teams

Arrange each team's players from weakest to strongest for efficient elimination

Elimination Rounds

In each round, every team releases their strongest remaining player

Score Calculation

The league awards points equal to the skill of the best player eliminated that round

Key Takeaway

🎯 Key Insight: Sorting each row initially allows us to efficiently access maximum elements without repeated searching, transforming an O(m×n²) brute force into an optimal O(m×n log n) solution!

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 5

The optimal solution sorts each row initially in O(m × n log n) time, then extracts maximum elements efficiently. The key insight is that after sorting, we can access the k-th largest element in O(1) time, eliminating the need for repeated maximum searches.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Find Max in Each Round)	O(m × n²)	O(1)	In each round, find and remove the maximum element from each row, then find the overall maximum
Sorting Each Row (Optimal)	O(m × n log n)	O(1)	Sort each row in ascending order, then extract maximum elements from the end efficiently

Brute Force (Find Max in Each Round) — Algorithm Steps

Continue until all rows are empty
In each round, find the maximum element in each non-empty row
Remove these maximum elements from their respective rows
Find the maximum among all removed elements and add to result
Repeat for the next round

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Matrix

Start with the original matrix, all elements intact

Round 1

Find max in each row: [4, 3]. Overall max: 4. Add 4 to result

Round 2

Find max in remaining elements: [2, 3]. Overall max: 3. Add 3 to result

Round 3

Find max in remaining elements: [1, 1]. Overall max: 1. Add 1 to result

Code -

solution.c — C

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

int findAndRemoveMax(int* row, int* size) {
    int max = row[0];
    int maxIdx = 0;
    
    // Find maximum
    for (int i = 1; i < *size; i++) {
        if (row[i] > max) {
            max = row[i];
            maxIdx = i;
        }
    }
    
    // Remove maximum by shifting elements
    for (int i = maxIdx; i < *size - 1; i++) {
        row[i] = row[i + 1];
    }
    (*size)--;
    
    return max;
}

int deleteGreatestValue(int** grid, int gridSize, int* gridColSize) {
    int result = 0;
    int n = gridColSize[0];
    
    // Create array to track row sizes
    int* rowSizes = (int*)malloc(gridSize * sizeof(int));
    for (int i = 0; i < gridSize; i++) {
        rowSizes[i] = gridColSize[i];
    }
    
    // Continue for n rounds
    for (int round = 0; round < n; round++) {
        int roundMax = 0;
        
        // Find and remove max from each row
        for (int i = 0; i < gridSize; i++) {
            int rowMax = findAndRemoveMax(grid[i], &rowSizes[i]);
            if (rowMax > roundMax) {
                roundMax = rowMax;
            }
        }
        
        result += roundMax;
    }
    
    free(rowSizes);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n²)

For each of n rounds, we scan each of m rows to find maximum among remaining elements, leading to O(m × n²) total operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximums, modifying the input matrix in-place

✓ Linear Space

26.4K Views

Medium Frequency

~15 min Avg. Time

892 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 (Find Max in Each Round) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler