Max Sum of Rectangle No Larger Than K - Problem

Array Binary Search Matrix Prefix Sum Ordered Set Hard

Given an m x n matrix matrix and an integer k, return the max sum of a rectangle in the matrix such that its sum is no larger than k.

It is guaranteed that there will be a rectangle with a sum no larger than k.

A rectangle is defined by its top-left corner and bottom-right corner.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: The rectangle with corners (0,0) to (0,2) has sum = 1 + 0 + 1 = 2, which equals k

Example 2 — Single Cell

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

› Output: 3

💡 Note: The entire rectangle [2,2,-1] has sum = 2 + 2 + (-1) = 3, which equals k

Example 3 — Negative Values

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

› Output: 0

💡 Note: Rectangle from (0,1) to (1,0) would be invalid. Single cells: -1,-1,2,3. Rectangles: [-1,2]=1, [-1,3]=2, [2,3]=5, [-1,-1]=-2, full=3. Only -1 ≤ 0, and -2 ≤ 0. Best is -1.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 100
-100 ≤ matrix[i][j] ≤ 100
-10⁵ ≤ k ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 35 a Amazon 30 f Facebook 25

The key insight is reducing the 2D rectangle problem to multiple 1D maximum subarray problems. Fix top/bottom rows, compress columns, then use Kadane's algorithm with binary search on prefix sums. Best approach achieves O(m²n log n) time, O(n) space.

Common Approaches

✓ Greedy

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

Brute Force - All Rectangles

⏱️ Time: O(m²n²(m+n)) Space: O(1)

Try all possible top-left and bottom-right corners, calculate sum for each rectangle directly, and track the maximum valid sum.

Kadane + Binary Search

⏱️ Time: O(m²n log n) Space: O(n)

Fix top and bottom rows, compress to 1D array, then solve maximum subarray ≤ k using Kadane's algorithm with binary search on prefix sums.

Prefix Sum Optimization

⏱️ Time: O(m²n²) Space: O(mn)

Precompute prefix sums to quickly calculate any rectangle sum, then check all rectangles efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int matrix[100][100];
static int prefixSum[101][101];

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int parseMatrix(char* line, int* rows, int* cols) {
    *rows = 0;
    *cols = 0;
    
    char* ptr = line;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++; // skip first '['
    
    int row = 0;
    while (*ptr && row < 100) {
        // Skip to '[' for this row
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // skip '['
        
        int col = 0;
        while (*ptr && *ptr != ']' && col < 100) {
            // Skip non-digit, non-minus
            while (*ptr && !isdigit(*ptr) && *ptr != '-') ptr++;
            if (!*ptr || *ptr == ']') break;
            
            // Parse number
            int num = 0;
            int negative = 0;
            if (*ptr == '-') {
                negative = 1;
                ptr++;
            }
            while (*ptr && isdigit(*ptr)) {
                num = num * 10 + (*ptr - '0');
                ptr++;
            }
            if (negative) num = -num;
            
            matrix[row][col] = num;
            col++;
        }
        
        if (row == 0) *cols = col;
        row++;
        
        // Skip past ']'
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
    }
    
    *rows = row;
    return 1;
}

int getRectangleSum(int r1, int c1, int r2, int c2) {
    return prefixSum[r2+1][c2+1] - prefixSum[r1][c2+1] - prefixSum[r2+1][c1] + prefixSum[r1][c1];
}

int maxSumSubarrayNoLargerThanK(int* arr, int n, int k) {
    int maxSum = INT_MIN;
    
    for (int i = 0; i < n; i++) {
        int sum = 0;
        for (int j = i; j < n; j++) {
            sum += arr[j];
            if (sum <= k && sum > maxSum) {
                maxSum = sum;
            }
        }
    }
    
    return maxSum;
}

int solution(int rows, int cols, int k) {
    // Build prefix sum array
    for (int i = 0; i <= rows; i++) {
        for (int j = 0; j <= cols; j++) {
            prefixSum[i][j] = 0;
        }
    }
    
    for (int i = 1; i <= rows; i++) {
        for (int j = 1; j <= cols; j++) {
            prefixSum[i][j] = matrix[i-1][j-1] + prefixSum[i-1][j] + prefixSum[i][j-1] - prefixSum[i-1][j-1];
        }
    }
    
    int maxSum = INT_MIN;
    
    // Try all possible rectangles
    for (int r1 = 0; r1 < rows; r1++) {
        for (int r2 = r1; r2 < rows; r2++) {
            // For fixed top and bottom rows, find max subarray sum <= k
            int arr[100];
            for (int c = 0; c < cols; c++) {
                arr[c] = getRectangleSum(r1, c, r2, c);
            }
            
            int result = maxSumSubarrayNoLargerThanK(arr, cols, k);
            if (result > maxSum) {
                maxSum = result;
            }
        }
    }
    
    return maxSum;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int rows, cols;
    parseMatrix(line, &rows, &cols);
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(rows, cols, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~35 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