Range Addition II - Practice Coding Problems

Range Addition II - Problem

Array Math Easy

Range Addition II is a clever optimization problem that tests your ability to recognize patterns and avoid unnecessary computation.

You start with an m × n matrix filled entirely with zeros. You're given an array of operations where each operation ops[i] = [ai, bi] means: increment by 1 every cell M[x][y] where 0 ≤ x < ai and 0 ≤ y < bi.

After performing all operations, your task is to count how many cells contain the maximum value in the matrix. The key insight? You don't actually need to simulate the entire matrix!

Example: If m=3, n=3 and ops=[[2,2],[3,3]], the matrix becomes:
[[2,2,1], [2,2,1], [1,1,1]]
The maximum value is 2, appearing in 4 cells, so return 4.

Input & Output

example_1.py — Basic Example

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

› Output: 4

💡 Note: After operations: [[2,2,1],[2,2,1],[1,1,1]]. Maximum value is 2, appearing in 4 cells (top-left 2×2 region).

example_2.py — No Operations

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

› Output: 9

💡 Note: No operations performed, so all cells remain 0. All 9 cells have the maximum value 0.

example_3.py — Single Operation

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

› Output: 4

💡 Note: Only one operation affects the 2×2 top-left region. These 4 cells have value 1, which is the maximum.

Visualization

Tap to expand

Understanding the Visualization

Individual Operations

Each operation covers a rectangle from (0,0) to (a-1, b-1)

Overlap Detection

Find the common area where ALL rectangles overlap

Mathematical Solution

Intersection dimensions = (min_a, min_b), so answer = min_a × min_b

Key Takeaway

🎯 Key Insight: The maximum value cells form a rectangle from (0,0) to (min_a-1, min_b-1). Count = min_a × min_b. No matrix simulation needed!

Time & Space Complexity

Time Complexity

⏱️

O(k)

Single pass through k operations to find minimum dimensions

✓ Linear Growth

Space Complexity

O(1)

Only storing two integer variables for minimum dimensions

✓ Linear Space

Constraints

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

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses geometric intersection instead of matrix simulation. Since all operations start from (0,0), the maximum value always appears in the intersection of all operation rectangles. Simply find the minimum width and minimum height across all operations - their product is the answer. This achieves O(k) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Matrix Simulation)	O(k × max(a) × max(b) + m × n)	O(m × n)	Actually create and modify the matrix, then count maximum values
Geometric Intersection (Optimal)	O(k)	O(1)	Find the intersection of all operation rectangles in one pass

Brute Force (Matrix Simulation) — Algorithm Steps

Initialize m×n matrix with all zeros
For each operation [a,b], increment M[x][y] for all 0≤x<a, 0≤y<b
Find the maximum value in the matrix
Count how many cells have this maximum value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Matrix

Start with m×n matrix of zeros

Apply Operations

Each operation increments a rectangular region

Find Maximum

Scan entire matrix to find the highest value

Count Maximum Cells

Count how many cells have the maximum value

Code -

solution.c — C

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

int maxCount(int m, int n, int** ops, int opsSize, int* opsColSize) {
    // Create matrix filled with zeros
    int** matrix = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        matrix[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Perform each operation
    for (int i = 0; i < opsSize; i++) {
        int a = ops[i][0], b = ops[i][1];
        for (int x = 0; x < a; x++) {
            for (int y = 0; y < b; y++) {
                matrix[x][y]++;
            }
        }
    }
    
    // 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 %d", &m, &n);
    // Simplified parsing
    printf("%d\n", maxCount(m, n, NULL, 0, NULL));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × max(a) × max(b) + m × n)

k operations each updating up to max(a)×max(b) cells, plus scanning the entire m×n matrix

✓ Linear Growth

Space Complexity

O(m × n)

Need to store the entire m×n matrix

⚡ Linearithmic Space

Constraints

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

18.8K Views

Medium Frequency

~12 min Avg. Time

856 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Matrix Simulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler