Modify the Matrix - Practice Coding Problems

Modify the Matrix - Problem

Array Matrix Easy

You're given an m × n integer matrix where some elements are marked with -1 as placeholders. Your task is to transform this matrix by replacing each -1 with the maximum value in its respective column.

Think of it like filling in missing data in a spreadsheet - wherever you see a -1, look up the column to find the highest number and use that as the replacement value.

Goal: Create a new matrix where all -1 values are replaced with their column's maximum value.

Example: If column 0 has values [3, -1, 5], the -1 should become 5 (the maximum in that column).

Input & Output

example_1.py — Basic Matrix

$ Input: matrix = [[1,-1],[4,5]]

› Output: [[1,5],[4,5]]

💡 Note: Column 0 has values [1,4], max is 4. Column 1 has values [-1,5], max is 5 (ignoring -1). So matrix[0][1] = -1 becomes 5.

example_2.py — Multiple -1s

$ Input: matrix = [[3,-1],[5,2]]

› Output: [[3,2],[5,2]]

💡 Note: Column 0: max of [3,5] is 5. Column 1: max of [-1,2] is 2. The -1 at position (0,1) becomes 2.

example_3.py — All -1s in column

$ Input: matrix = [[1,2,3],[-1,-1,-1],[4,5,6]]

› Output: [[1,2,3],[4,5,6],[4,5,6]]

💡 Note: Column maximums are [4,5,6]. All -1s in row 1 are replaced with their respective column maximums.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 50
-1 ≤ matrix[i][j] ≤ 100
The input is guaranteed to have at least one non-(-1) value in each column that contains a -1

Visualization

Tap to expand

First Pass: Scan matrix to find maximum in each column (ignore -1 values)2. Store Maximums: Keep column max values in array: [4, 8, 6]3. Second Pass: Replace each -1 with its column's maximum value⏰ Time: O(m×n) | 💾 Space: O(n) | ✅ Optimal Solution

Understanding the Visualization

Identify Missing Values

Find all -1 values that need to be replaced

Calculate Column Maximums

For each column, find the maximum non-(-1) value

Replace Values

Replace each -1 with its column's maximum value

Return Result

All missing values filled with appropriate maximums

Key Takeaway

🎯 Key Insight: Pre-computing column maximums eliminates redundant scanning and achieves optimal O(m×n) time complexity.

Asked in

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

The optimal solution uses a two-pass approach: first pass finds the maximum value in each column (ignoring -1s), second pass replaces all -1 values with their respective column maximums. Time complexity: O(m×n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Optimal Solution	O(m × n)	O(n)	First pass finds all column maximums, second pass replaces all -1 values
Brute Force (Find Max Per -1)	O(m² × n)	O(1)	For each -1 found, scan its entire column to find the maximum value

Two-Pass Optimal Solution — Algorithm Steps

First pass: Iterate through matrix to find maximum value in each column
Store column maximums in an array, ignoring -1 values
Second pass: Iterate through matrix again
Replace each -1 with the pre-computed maximum of its column
Return the modified matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Scan matrix to find maximum in each column

Store Maximums

Keep track of column maximums in array

Second Pass

Replace all -1 values using stored maximums

Complete

Matrix transformation completed efficiently

Code -

solution.c — C

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

int** modifyMatrix(int** matrix, int m, int n) {
    // First pass: find maximum in each column
    int* colMax = (int*)malloc(n * sizeof(int));
    for (int j = 0; j < n; j++) {
        colMax[j] = INT_MIN;
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] != -1) {
                colMax[j] = (matrix[i][j] > colMax[j]) ? matrix[i][j] : colMax[j];
            }
        }
    }
    
    // Second pass: replace -1 with column maximum
    int** answer = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        answer[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == -1) {
                answer[i][j] = colMax[j];
            } else {
                answer[i][j] = matrix[i][j];
            }
        }
    }
    
    free(colMax);
    return answer;
}

int main() {
    // Input parsing and function call would be implemented here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Two passes through the m×n matrix: O(mn) + O(mn) = O(mn)

✓ Linear Growth

Space Complexity

O(n)

Extra space for storing maximum of each of the n columns

⚡ Linearithmic Space

23.8K Views

Medium Frequency

~8 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

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler