Sum of Matrix After Queries

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],[0,0,2],[0,0,2]]. Query [0,0,3] sets row 0 to [3,3,3], final matrix: [[3,3,3],[0,0,2],[0,0,2]]. Sum = 3+3+3+0+0+2+0+0+2 = 13.

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

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

✓ Brute Force (Simulate All Operations)

⏱️ Time: O(q × n) Space: O(n²)

The straightforward approach: create an n×n matrix, process each query by updating entire rows or columns, then sum all elements at the end.

Reverse Processing with Hash Sets

⏱️ Time: O(q) Space: O(n)

The key insight is that only the last operation affecting each cell matters. By processing queries in reverse order, we can track which rows and columns haven't been modified yet and calculate their contribution efficiently.

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>
#include <string.h>

void parseArray(const char* str, int queries[][3], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',' || *p == '[') p++;
        if (*p == ']' || *p == '\0') break;
        
        queries[*size][0] = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        queries[*size][1] = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        queries[*size][2] = (int)strtol(p, (char**)&p, 10);
        
        while (*p && *p != ']' && *p != '[') p++;
        if (*p == ']') p++;
        
        (*size)++;
    }
}

static int matrix[1000][1000];

long long matrixSumQueries(int n, int queries[][3], int queriesSize) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            matrix[i][j] = 0;
        }
    }
    
    for (int q = 0; q < queriesSize; q++) {
        int type_val = queries[q][0], index = queries[q][1], val = queries[q][2];
        if (type_val == 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];
        }
    }
    return sum;
}

int main() {
    int n;
    scanf("%d\n", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    static int queries[1000][3];
    int queriesSize;
    parseArray(line, queries, &queriesSize);
    
    printf("%lld\n", matrixSumQueries(n, queries, queriesSize));
    return 0;
}

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