Count Submatrices with Top-Left Element and Sum Less Than k

Count Submatrices with Top-Left Element and Sum Less Than k - Problem

You are given a 0-indexed integer matrix grid and an integer k.

Return the number of submatrices that contain the top-left element of the grid, and have a sum less than or equal to k.

A submatrix is a rectangular region within the matrix. For this problem, we only consider submatrices that include the element at position (0,0).

Input & Output

Example 1 — Basic Case

$ Input: grid = [[7,6],[6,4]], k = 13

› Output: 3

💡 Note: All possible submatrices: (0,0)→sum=7≤13 ✓, (0,0)→(0,1)→sum=13≤13 ✓, (0,0)→(1,0)→sum=13≤13 ✓, (0,0)→(1,1)→sum=23>13 ✗. Total: 3 valid submatrices.

Example 2 — Single Element

$ Input: grid = [[7]], k = 6

› Output: 0

💡 Note: Only one submatrix: (0,0) with sum=7 > 6, so no valid submatrices.

Example 3 — All Valid

$ Input: grid = [[1,1],[1,1]], k = 10

› Output: 4

💡 Note: All submatrices have small sums: 1, 2, 2, 4 - all ≤ 10, so count = 4.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
0 ≤ grid[i][j] ≤ 1000
0 ≤ k ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is to use 2D prefix sums for fast rectangle sum queries. Build a prefix sum array where prefix[i][j] = sum of rectangle from (0,0) to (i,j). Then check each possible submatrix in O(1) time. Best approach: 2D Prefix Sum. Time: O(mn), Space: O(mn).

Common Approaches

✓ Optimized

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

2D Prefix Sum

⏱️ Time: O(mn) Space: O(mn)

Build a 2D prefix sum array where prefix[i][j] represents sum of all elements from (0,0) to (i,j). Then check each possible submatrix in constant time.

Brute Force

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

For each possible bottom-right corner (i,j), directly sum all elements in the rectangle from (0,0) to (i,j). Count how many have sum ≤ k.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int countSubmatrices(int** grid, int gridSize, int* gridColSize, int k) {
    int count = 0;
    int m = gridSize;
    int n = gridColSize[0];
    
    // Try all possible bottom-right corners (i, j)
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Calculate sum of submatrix from (0,0) to (i,j)
            int sum = 0;
            for (int r = 0; r <= i; r++) {
                for (int c = 0; c <= j; c++) {
                    sum += grid[r][c];
                }
            }
            
            if (sum <= k) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    
    // Read grid
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array manually
    int** grid = NULL;
    int* gridColSize = NULL;
    int gridSize = 0;
    
    // Count rows by counting '],' patterns
    char* temp = line;
    int rows = 0;
    while ((temp = strstr(temp, "],")) != NULL) {
        rows++;
        temp += 2;
    }
    rows++; // Add one more for the last row
    
    gridSize = rows;
    grid = (int**)malloc(rows * sizeof(int*));
    gridColSize = (int*)malloc(rows * sizeof(int));
    
    // Parse each row
    char* ptr = line;
    while (*ptr != '[') ptr++; // Find first [
    ptr++; // Skip initial [
    
    for (int i = 0; i < rows; i++) {
        // Skip to next row's opening bracket
        while (*ptr != '[') ptr++;
        ptr++; // Skip [
        
        // Count elements in this row
        char* rowStart = ptr;
        int cols = 0;
        while (*ptr != ']') {
            if (*ptr == ',' || (*ptr >= '0' && *ptr <= '9')) {
                if (*ptr >= '0' && *ptr <= '9') {
                    cols++;
                    while (*ptr >= '0' && *ptr <= '9') ptr++;
                } else {
                    ptr++;
                }
            } else {
                ptr++;
            }
        }
        
        gridColSize[i] = cols;
        grid[i] = (int*)malloc(cols * sizeof(int));
        
        // Parse the numbers
        ptr = rowStart;
        int colIdx = 0;
        while (*ptr != ']' && colIdx < cols) {
            if (*ptr >= '0' && *ptr <= '9') {
                grid[i][colIdx++] = (int)strtol(ptr, &ptr, 10);
            } else {
                ptr++;
            }
        }
        
        // Move past this row's closing bracket
        while (*ptr != ']') ptr++;
        ptr++; // Skip ]
    }
    
    // Read k
    int k;
    scanf("%d", &k);
    
    int result = countSubmatrices(grid, gridSize, gridColSize, k);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < gridSize; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

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