Sum of Matrix After Queries - Practice Coding Problems

Sum of Matrix After Queries - Problem

Matrix Query Operations: You're given an n × n matrix initially filled with zeros and a series of queries that modify entire rows or columns at once.

Each query has three parts: [type, index, value]
• If type = 0: Set all values in row index to value
• If type = 1: Set all values in column index to value

Goal: After processing all queries in order, return the sum of all elements in the matrix.

Key Challenge: Later queries can overwrite earlier ones, so the order matters! A column operation after a row operation will overwrite the intersection cell.

Input & Output

example_1.py — Basic Matrix Operations

$ Input: n = 3, queries = [[0,0,1],[1,2,2],[0,0,3]]

› Output: 13

💡 Note: Initial 3×3 matrix of zeros. Query [0,0,1] sets row 0 to [1,1,1]. Query [1,2,2] sets column 2 to [2,2,2], creating matrix [[1,1,2],[1,1,2],[1,1,2]]. Query [0,0,3] sets row 0 to [3,3,3], final matrix: [[3,3,3],[1,1,2],[1,1,2]]. Sum = 3+3+3+1+1+2+1+1+2 = 17. Wait, let me recalculate: [[3,3,2],[1,1,2],[1,1,2]] since column operation happened before final row operation. Sum = 3+3+2+1+1+2+1+1+2 = 16. Actually, the intersection cell (0,2) gets the final row value 3. So final matrix is [[3,3,3],[1,1,2],[1,1,2]] and sum is 17.

example_2.py — Single Operation

$ Input: n = 2, queries = [[1,0,5]]

› Output: 10

💡 Note: Start with 2×2 matrix of zeros. Query [1,0,5] sets column 0 to value 5. Final matrix: [[5,0],[5,0]]. Sum = 5+0+5+0 = 10.

example_3.py — Overwriting Operations

$ Input: n = 2, queries = [[0,0,2],[0,0,3],[1,1,4]]

› Output: 14

💡 Note: Initial 2×2 zeros. [0,0,2] sets row 0 to [2,2]. [0,0,3] overwrites row 0 to [3,3]. [1,1,4] sets column 1 to [4,4]. Final matrix: [[3,4],[3,4]]. Sum = 3+4+3+4 = 14.

Constraints

1 ≤ n ≤ 10⁴
1 ≤ queries.length ≤ 5 × 10⁴
queries[i].length == 3
0 ≤ type_i ≤ 1
0 ≤ index_i < n
0 ≤ val_i ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Start from Final State

Begin with the last command - it definitely affects the final result

Work Backwards

For each earlier command, check if it affects areas not yet processed

Calculate Impact

Count how many cells each command actually influences in the final state

Sum Contributions

Add up all the effective contributions without building the full matrix

Key Takeaway

🎯 Key Insight: Process queries in reverse order - only the last operation affecting each cell matters, allowing us to calculate the sum without building the entire matrix!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach processes queries in reverse order using hash sets to track visited rows and columns. Key insight: only the last operation affecting each cell matters, so we can calculate contributions efficiently without building the actual matrix. Time complexity: O(q), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulate All Operations)	O(q × n)	O(n²)	Create the actual matrix and apply each query, then sum all elements
Reverse Processing with Hash Sets	O(q)	O(n)	Process queries in reverse order to track which rows/columns are affected by later operations

Brute Force (Simulate All Operations) — Algorithm Steps

Initialize n×n matrix with zeros
For each query, update entire row or column with given value
Sum all elements in the final matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Matrix

Create n×n matrix filled with zeros

Apply Row Query

Set entire row to new value

Apply Column Query

Set entire column to new value, overwriting intersections

Calculate Sum

Sum all elements in final matrix

Code -

solution.c — C

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

long long matrixSumQueries(int n, int** queries, int queriesSize) {
    int** matrix = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        matrix[i] = (int*)calloc(n, sizeof(int));
    }
    
    for (int q = 0; q < queriesSize; q++) {
        int type = queries[q][0], index = queries[q][1], val = queries[q][2];
        if (type == 0) { // Row operation
            for (int j = 0; j < n; j++) {
                matrix[index][j] = val;
            }
        } else { // Column operation
            for (int i = 0; i < n; i++) {
                matrix[i][index] = val;
            }
        }
    }
    
    long long sum = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            sum += matrix[i][j];
        }
        free(matrix[i]);
    }
    free(matrix);
    return sum;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

q queries, each updating n elements in a row/column

✓ Linear Growth

Space Complexity

O(n²)

Store the entire n×n matrix

⚠ Quadratic Space

37.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 (Simulate All Operations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler