Max Sum of Rectangle No Larger Than K - Practice Coding Problems

Max Sum of Rectangle No Larger Than K - Problem

Array Binary Search Matrix Prefix Sum Ordered Set Hard

Imagine you're a treasure hunter exploring a 2D grid filled with both precious gems and cursed artifacts. Each cell contains a value that could be positive (gems) or negative (curses). Your goal is to find the most valuable rectangular region you can claim, but there's a catch!

You have a maximum budget of k that represents the most "curse penalty" you can afford to pay. You need to find the rectangle with the maximum sum such that this sum doesn't exceed your budget k.

Input: An m × n integer matrix and an integer k representing your budget.

Output: The maximum sum of any rectangle in the matrix that is ≤ k.

Note: It's guaranteed that at least one valid rectangle exists (worst case, a single non-positive cell).

Input & Output

example_1.py — Basic Case

$ Input: matrix = [[1,0,1],[0,-2,3]], k = 2

› Output: 2

💡 Note: The rectangle with coordinates (0,2) to (1,2) has sum = 1 + 3 = 4, but 4 > 2. The rectangle (0,0) to (0,2) has sum = 1 + 0 + 1 = 2, which equals k.

example_2.py — Single Element

$ Input: matrix = [[2,2,-1]], k = 3

› Output: 3

💡 Note: The rectangle (0,0) to (0,1) has sum = 2 + 2 = 4 > 3. The rectangle (0,0) to (0,0) has sum = 2 ≤ 3. The rectangle (0,1) to (0,1) has sum = 2 ≤ 3. The best we can do is sum = 3 from rectangle containing just the first two elements: 2+2=4 is too big, but 2+2-1=3 works if we take (0,0) to (0,2) then subtract... Actually, let's try subarray [2,2] which gives us exactly 3 when we consider [2,1] where 1 comes from 2-1.

example_3.py — All Negative

$ Input: matrix = [[-1,-2],[-3,-4]], k = -1

› Output: -1

💡 Note: All elements are negative. The best single element is -1, which equals k exactly. Any larger rectangle would have a more negative (smaller) sum.

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

O(mn) to build prefix sums + O(m²n²) to check all rectangles with O(1) sum calculation

⚠ Quadratic Growth

Space Complexity

O(mn)

Additional space for the 2D prefix sum array

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 100
-100 ≤ matrix[i][j] ≤ 100
-10⁵ ≤ k ≤ 10⁵
At least one rectangle with sum ≤ k is guaranteed to exist

Asked in

The optimal solution uses row compression with binary search achieving O(m²n log n) time. For each pair of rows, compress the matrix into a 1D array, then solve the maximum subarray sum ≤ k problem using cumulative sums and binary search on a sorted data structure.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum + Enumeration	O(m²n²)	O(mn)	Build prefix sums first, then efficiently calculate any rectangle sum in O(1)
Row Compression + Binary Search (Optimal)	O(m²n log n)	O(n)	Compress 2D to 1D problems and use binary search on sorted cumulative sums
Brute Force (All Rectangles)	O(m²n²)	O(1)	Check every possible rectangle by trying all combinations of top-left and bottom-right corners

Prefix Sum + Enumeration — Algorithm Steps

Build 2D prefix sum array where prefix[i][j] = sum from (0,0) to (i-1,j-1)
For each possible rectangle (r1,c1) to (r2,c2), calculate sum using prefix sums
Use formula: sum = prefix[r2+1][c2+1] - prefix[r1][c2+1] - prefix[r2+1][c1] + prefix[r1][c1]
Keep track of maximum valid sum ≤ k

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Array

prefix[i][j] = sum from (0,0) to (i-1,j-1)

Rectangle Formula

Use inclusion-exclusion principle

Fast Calculation

Any rectangle sum in O(1) time

Check All

Still need to check all rectangles

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int maxSumSubmatrix(int** matrix, int matrixSize, int* matrixColSize, int k) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return 0;
    }
    
    int m = matrixSize, n = matrixColSize[0];
    
    // Build prefix sum array
    int** prefix = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        prefix[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            prefix[i][j] = matrix[i-1][j-1] + prefix[i-1][j] +
                          prefix[i][j-1] - prefix[i-1][j-1];
        }
    }
    
    int maxSum = INT_MIN;
    
    // Try all possible rectangles using prefix sums
    for (int r1 = 0; r1 < m; r1++) {
        for (int c1 = 0; c1 < n; c1++) {
            for (int r2 = r1; r2 < m; r2++) {
                for (int c2 = c1; c2 < n; c2++) {
                    // Calculate rectangle sum using prefix sums
                    int rectSum = prefix[r2+1][c2+1] - prefix[r1][c2+1] -
                                 prefix[r2+1][c1] + prefix[r1][c1];
                    
                    if (rectSum <= k) {
                        maxSum = max(maxSum, rectSum);
                    }
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i <= m; i++) {
        free(prefix[i]);
    }
    free(prefix);
    
    return maxSum;
}

int main() {
    int data[2][3] = {{1, 0, 1}, {0, -2, 3}};
    int* matrix[2] = {data[0], data[1]};
    int colSizes[2] = {3, 3};
    int k = 2;
    
    printf("%d\n", maxSumSubmatrix(matrix, 2, colSizes, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

O(mn) to build prefix sums + O(m²n²) to check all rectangles with O(1) sum calculation

⚠ Quadratic Growth

Space Complexity

O(mn)

Additional space for the 2D prefix sum array

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 100
-100 ≤ matrix[i][j] ≤ 100
-10⁵ ≤ k ≤ 10⁵
At least one rectangle with sum ≤ k is guaranteed to exist

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum + Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler