Increment Submatrices by One - Practice Coding Problems

Increment Submatrices by One - Problem

🎯 Matrix Range Updates Challenge

Imagine you're managing a grid-based system where you need to efficiently process multiple range update operations. You start with an n × n matrix filled with zeros, and you're given a series of queries that increment rectangular regions.

Your Task: For each query [row1, col1, row2, col2], add 1 to every element in the submatrix from top-left corner (row1, col1) to bottom-right corner (row2, col2) inclusive.

Example: If you have a 3×3 zero matrix and query [1,1,2,2], you increment the 2×2 bottom-right submatrix.

🚀 The Challenge: Can you solve this efficiently when dealing with thousands of queries on large matrices?

Input & Output

example_1.py — Basic Range Update

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

› Output: [[0,0,0],[0,1,1],[0,1,1]]

💡 Note: Start with 3×3 zero matrix. Query [1,1,2,2] increments the 2×2 submatrix from (1,1) to (2,2). Only the bottom-right 4 cells are incremented by 1.

example_2.py — Multiple Overlapping Queries

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

› Output: [[1,1],[2,2]]

💡 Note: First query increments entire 2×2 matrix. Second query increments bottom row again. Cell (1,0) and (1,1) are incremented twice, resulting in value 2.

example_3.py — Single Cell Update

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

› Output: [[1,0,0],[0,0,0],[0,0,1]]

💡 Note: Two single-cell updates: top-left corner (0,0) and bottom-right corner (2,2). Each gets incremented by 1, all other cells remain 0.

Constraints

1 ≤ n ≤ 1000
1 ≤ queries.length ≤ 5 × 10⁴
queries[i].length == 4
0 ≤ row1_i ≤ row2_i < n
0 ≤ col1_i ≤ col2_i < n
All coordinates are 0-indexed

Visualization

Tap to expand

Understanding the Visualization

Install Control Points

Place +1 signal at top-left corner of each lighting zone

Add Boundary Stoppers

Place -1 signals at right and bottom boundaries to contain the effect

Broadcast Changes

Send cumulative signals across the grid using 2D propagation

Final Illumination

Each room receives the correct brightness level automatically

Key Takeaway

🎯 Key Insight: Instead of manually adjusting each room's lighting, use smart control points that automatically propagate changes across defined rectangular zones - saving massive time and energy!

Asked in

G Google 42 a Amazon 35 ⊞ Microsoft 28 f Meta 22

The optimal solution uses 2D Difference Array technique: instead of updating each cell individually (O(q×n²)), we mark rectangle boundaries with +1/-1 values in O(1) per query, then compute the final matrix using 2D prefix sum in O(n²). This reduces time complexity from O(q×n²) to O(q + n²), making it efficient for large inputs with many queries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct Range Updates)	O(q × n²)	O(1)	For each query, iterate through the entire submatrix and increment each cell by 1
2D Difference Array (Optimal)	O(q + n²)	O(n²)	Use differential marking at rectangle corners, then compute 2D prefix sum to get final values

Brute Force (Direct Range Updates) — Algorithm Steps

Initialize n×n matrix with zeros
For each query [r1, c1, r2, c2]:
Use nested loops: for row from r1 to r2, for col from c1 to c2
Increment mat[row][col] by 1
Return the final matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Matrix

Start with n×n zero matrix

Process Query

For each query, visit every cell in the rectangle

Increment Cells

Add 1 to each cell in the range

Final Result

Matrix after all queries processed

Code -

solution.c — C

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

int** rangeAddQueries(int n, int** queries, int querySize) {
    // Initialize n x n matrix with zeros
    int** mat = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        mat[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Process each query
    for (int i = 0; i < querySize; i++) {
        int row1 = queries[i][0], col1 = queries[i][1];
        int row2 = queries[i][2], col2 = queries[i][3];
        
        // Increment all cells in the rectangle
        for (int r = row1; r <= row2; r++) {
            for (int c = col1; c <= col2; c++) {
                mat[r][c]++;
            }
        }
    }
    
    return mat;
}

int main() {
    int n;
    scanf("%d", &n);
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n²)

q queries, each potentially updating the entire n×n matrix

⚠ Quadratic Growth

Space Complexity

O(1)

Only using the output matrix, no extra space

✓ Linear Space

73.9K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

🎯 Matrix Range Updates Challenge

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Direct Range Updates) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler