Sum in a Matrix
Here’s a straightforward approach to solve the problem according to the requirements:
 Iterate through the matrix until it becomes empty.
 In each iteration, find and remove the largest number from each row, and keep track of the largest number among them.
 Add that largest number to the score.
We can implement the algorithm using the following code:


This code will return the final score after performing the operations on the given matrix, satisfying the constraints.
10 Prerequisite LeetCode Problems
For “2679. Sum in a Matrix”, the following is a good preparation:
“378. Kth Smallest Element in a Sorted Matrix”: It provides a clear understanding of how to interact with values in a sorted matrix.
“240. Search a 2D Matrix II”: This problem gives practice on finding specific elements in a 2D array which is beneficial for the main problem.
“200. Number of Islands”: This problem is about matrix traversal which helps understand how to navigate through a matrix.
“88. Merge Sorted Array”: This problem helps understand sorting of arrays which is crucial for the main problem to identify the largest element in each row.
“64. Minimum Path Sum”: The dynamic programming concept used in this problem can be helpful to optimize the selection of maximum elements in the main problem.
“42. Trapping Rain Water”: This problem helps understand the concept of taking maximum/minimum of elements in an array which is useful for the main problem.
“121. Best Time to Buy and Sell Stock”: Solving this problem can help understand how to keep track of maximum values which is crucial for the main problem.
“215. Kth Largest Element in an Array”: This problem helps in understanding how to interact with maximum elements in an array which is fundamental for the main problem.
“414. Third Maximum Number”: This problem focuses on handling maximum values in an array, a crucial concept in the main problem.
“485. Max Consecutive Ones”: It will give you practice on finding maximum values in subarrays.
These are beneficial as they cover a range of techniques and concepts such as array traversal, dynamic programming, handling maximum values, and interacting with 2D matrices that are important for solving the main problem.


You are given a 0indexed 2D integer array nums. Initially, your score is 0. Perform the following operations until the matrix becomes empty:
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. Identify the highest number amongst all those removed in step 1. Add that number to your score. Return the final score.
Example 1:
Input: nums = [[7,2,1],[6,4,2],[6,5,3],[3,2,1]] Output: 15 Explanation: In the first operation, we remove 7, 6, 6, and 3. We then add 7 to our score. Next, we remove 2, 4, 5, and 2. We add 5 to our score. Lastly, we remove 1, 2, 3, and 1. We add 3 to our score. Thus, our final score is 7 + 5 + 3 = 15.
Example 2:
Input: nums = [[1]] Output: 1 Explanation: We remove 1 and add it to the answer. We return 1.
Constraints:
1 <= nums.length <= 300 1 <= nums[i].length <= 500 0 <= nums[i][j] <= 103
Problem Classification
This falls into the domain of Computer Science and specifically within the realm of Data Structures (e.g., Arrays) and Algorithms. This involves understanding and manipulating 2D arrays and applying an algorithm to solve a particular problem.
Here are the ‘What’ components of the problem:
 You are given a 2D integer array (or matrix) named ’nums’.
 Initially, your score is 0.
 You need to perform operations until the matrix becomes empty:
 From each row in the matrix, select the largest number and remove it.
 Amongst all those removed numbers, identify the highest number and add it to your score.
 The final task is to return the final score after all operations have been performed.
This problem can be further classified as an optimization problem where the goal is to maximize the score by strategically selecting and removing numbers from the 2D array. It requires a good understanding of array manipulation, iterative processes, and how to implement a selection procedure based on specific criteria (i.e., choosing the largest numbers). A successful solution will need to account for maintaining the state of the 2D array as operations are performed and updating the score accordingly.
Language Agnostic Coding Drills
Variable Initialization: The concept of creating and initializing variables. Here
ans
andm
are examples. This is a basic concept necessary in virtually every piece of software.List Traversal: Iterating over elements in a list, which is demonstrated by the outer
for
loop iterating over thenums
list and the innerfor
loop iterating over the columns. This is a fundamental concept for handling lists or arrays.List Sorting: Sorting a list of numbers in ascending order using Python’s builtin
sort()
function. This is applied to each row of thenums
2D list.Indexing in 2D Lists: Accessing elements of a 2D list using indices. In the statement
nums[j][i]
,j
andi
are used to access specific elements in the 2D list.Conditional Statements: Using
if
statement to check a condition. Here it checks ifm < nums[j][i]
and updatesm
accordingly.Updating Variables: The concept of modifying a variable’s value, which is seen when
m
is updated to the maximum value in the column andans
is incremented bym
after each iteration of the inner loop.
Once these concepts have been mastered, they can be pieced together to solve this problem. The logic involved here is:
We first iterate through each row in the 2D list and sort the numbers. This is done to ensure the numbers are in order, facilitating the process of identifying the largest number.
We then iterate through the columns in the sorted 2D list. For each column, we find the largest number by comparing the number at each row in the column with
m
, the maximum value found so far. If the number at the current row is larger thanm
, we updatem
.After going through all rows in a column, we add the maximum value
m
toans
, our running total.We repeat steps 23 for all columns.
Finally, we return
ans
, which contains the sum of the maximum values from each column.
This approach effectively breaks down the problem into smaller steps that can be tackled individually, and these steps correspond to the coding drills identified. The drills can be seen as the building blocks to form the final solution to the problem.
Targeted Drills in Python
Let’s dive into the Pythonbased coding drills for each of the identified concepts:
 Variable Initialization


 List Traversal


 List Sorting


 Indexing in 2D Lists


 Conditional Statements


 Updating Variables


Once you understand and can implement these basic coding drills, you can start to combine them to solve more complex problems, like the one in the question. The matrixSum
method combines all these drills to solve the problem:
 We first initialize the
ans
variable to hold the final answer.  We iterate over each row in the input matrix and sort it.
 We then iterate over each column in the matrix. For each column, we iterate over each row, keeping track of the maximum value in the column.
 After finding the maximum value for a column, we add it to
ans
.  Finally, we return
ans
as the result.
Each of these steps corresponds to one or more of the drills, and the drills are combined in a way that solves the problem. This highlights how even complex problems can be broken down into simpler, more manageable parts.