Range Addition II

Range Addition II - Problem

Array Math Easy

You are given an m x n matrix M initialized with all 0's and an array of operations ops, where ops[i] = [a_i, b_i] means M[x][y] should be incremented by one for all 0 ≤ x < a_i and 0 ≤ y < b_i.

Count and return the number of maximum integers in the matrix after performing all the operations.

Input & Output

Example 1 — Basic Operations

$ Input: m = 3, n = 3, ops = [[2,2],[3,3]]

› Output: 4

💡 Note: Operation [2,2] increments cells (0,0), (0,1), (1,0), (1,1). Operation [3,3] increments all 9 cells. The intersection (0,0), (0,1), (1,0), (1,1) gets incremented twice, so 4 cells have maximum value.

Example 2 — Empty Operations

$ Input: m = 3, n = 3, ops = []

› Output: 9

💡 Note: No operations means all cells remain 0. All 9 cells have the same maximum value of 0.

Example 3 — Single Cell Intersection

$ Input: m = 3, n = 3, ops = [[2,2],[3,3],[1,1]]

› Output: 1

💡 Note: The intersection of all operations is min(2,3,1) × min(2,3,1) = 1×1. Only cell (0,0) receives all increments.

Constraints

1 ≤ m, n ≤ 4 × 10⁴
0 ≤ ops.length ≤ 10⁴
ops[i].length == 2
1 ≤ a_i ≤ m
1 ≤ b_i ≤ n

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 15 M Microsoft 20

The key insight is that maximum values only occur in the intersection of all operation rectangles. We find the minimum dimensions across all operations to determine this intersection area. Best approach uses mathematical optimization in O(k) time and O(1) space.

Common Approaches

✓ Brute Force Matrix Simulation

⏱️ Time: O(k × a × b) Space: O(m × n)

Build the m×n matrix, perform each operation by incrementing all cells in the specified range, then find maximum value and count occurrences.

Mathematical Optimization

⏱️ Time: O(k) Space: O(1)

The key insight is that maximum values occur only in the intersection of all operation rectangles. We find the minimum dimensions across all operations.

Brute Force Matrix Simulation — Algorithm Steps

Step 1: Create m×n matrix initialized to 0
Step 2: For each operation [a,b], increment M[x][y] for 0≤x<a, 0≤y<b
Step 3: Find maximum value and count how many cells have this value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Matrix

Create 3×3 matrix filled with zeros

Apply Operations

Increment cells according to each operation range

Count Maximum

Find max value and count occurrences

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int m, int n, int ops[][2], int opsSize) {
    // Create matrix initialized with zeros
    int** matrix = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        matrix[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Apply each operation
    for (int k = 0; k < opsSize; k++) {
        int a = ops[k][0], b = ops[k][1];
        for (int i = 0; i < min(a, m); i++) {
            for (int j = 0; j < min(b, n); j++) {
                matrix[i][j]++;
            }
        }
    }
    
    // Find maximum value
    int maxVal = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] > maxVal) {
                maxVal = matrix[i][j];
            }
        }
    }
    
    // Count cells with maximum value
    int count = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == maxVal) {
                count++;
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return count;
}

int main() {
    int m, n;
    scanf("%d", &m);
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    // Simple parsing for operations
    int ops[1000][2];
    int opsSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* ptr = line + 1; // skip opening [
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                ops[opsSize][0] = atoi(ptr);
                while (*ptr && *ptr != ',') ptr++;
                ptr++; // skip comma
                ops[opsSize][1] = atoi(ptr);
                opsSize++;
                while (*ptr && *ptr != ']') ptr++;
                ptr++; // skip ]
            } else {
                ptr++;
            }
        }
    }
    
    int result = solution(m, n, ops, opsSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × a × b)

k operations, each touching up to a×b cells

✓ Linear Growth

Space Complexity

O(m × n)

Store entire m×n matrix

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

890 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 Matrix Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler