Increment Submatrices by One

Increment Submatrices by One - Problem

You are given a positive integer n, indicating that we initially have an n x n 0-indexed integer matrix mat filled with zeroes.

You are also given a 2D integer array query. For each query[i] = [row1i, col1i, row2i, col2i], you should do the following operation:

Add 1 to every element in the submatrix with the top left corner (row1i, col1i) and the bottom right corner (row2i, col2i). That is, add 1 to mat[x][y] for all row1i <= x <= row2i and col1i <= y <= col2i.

Return the matrix mat after performing every query.

Input & Output

Example 1 — Basic Rectangle 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 submatrix from (1,1) to (2,2), so cells [1,1], [1,2], [2,1], [2,2] become 1.

Example 2 — Multiple Overlapping Queries

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

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

💡 Note: First query increments entire 2×2 matrix. Second query increments only cell (0,0). Final: (0,0) has value 2, others have value 1.

Example 3 — Single Cell Update

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

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

💡 Note: Query targets only cell (1,1), incrementing it from 0 to 1. All other cells remain 0.

Constraints

1 ≤ n ≤ 500
1 ≤ queries.length ≤ 10⁴
queries[i].length == 4
0 ≤ row1_i ≤ row2_i < n
0 ≤ col1_i ≤ col2_i < n

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use a 2D difference array to mark rectangle boundaries instead of updating every cell. The optimal approach uses difference arrays to mark boundaries in O(1) per query, then computes 2D prefix sums to get final values. Time: O(q + n²), Space: O(n²)

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 1d

⏱️ Time: N/A Space: N/A

Optimized

⏱️ Time: N/A Space: N/A

2D Difference Array

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

Instead of updating every cell in each rectangle, we mark only the corners of rectangles in a difference array. Then we compute 2D prefix sums to get the final result efficiently.

Brute Force

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

Initialize an n×n matrix with zeros. For each query, iterate through all cells in the specified rectangle and increment each by 1. This directly implements the problem requirements.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int memo[100000];
int memoSet[100000];

int dfs(int* nums, int numsSize, int k, int i) {
    if (i == numsSize - 1) {
        return nums[i];
    }
    
    if (memoSet[i]) {
        return memo[i];
    }
    
    int maxScore = INT_MIN;
    int end = (i + k < numsSize - 1) ? i + k : numsSize - 1;
    
    for (int j = i + 1; j <= end; j++) {
        int score = nums[i] + dfs(nums, numsSize, k, j);
        if (score > maxScore) {
            maxScore = score;
        }
    }
    
    memo[i] = maxScore;
    memoSet[i] = 1;
    return maxScore;
}

int solution(int* nums, int numsSize, int k) {
    memset(memoSet, 0, sizeof(memoSet));
    return dfs(nums, numsSize, k, 0);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler