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

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

You're given a 2D integer matrix and need to find how many submatrices meet two specific criteria:

The submatrix must contain the top-left element of the original matrix (position [0,0])
The sum of all elements in the submatrix must be ≤ k

A submatrix is defined by its top-left corner at [0,0] and bottom-right corner at [i,j], containing all elements from [0,0] to [i,j] inclusive.

Example: If the matrix is [[1,2],[3,4]] and k=4, the valid submatrices are:

[1] (sum = 1 ≤ 4) ✓
[1,2] (sum = 3 ≤ 4) ✓
[[1],[3]] (sum = 4 ≤ 4) ✓
[[1,2],[3,4]] (sum = 10 > 4) ✗

Return the count of valid submatrices.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Valid submatrices: [1](1≤4), [1,1](2≤4), [[1],[1]](2≤4), [[1,1],[1,1]](4≤4). The 3×3 matrix has sum 9>4, so invalid.

example_2.py — Mixed Values

$ Input: grid = [[1,2,3],[4,5,6]], k = 10

› Output: 3

💡 Note: Valid submatrices: [1](1≤10), [1,2](3≤10), [[1],[4]](5≤10). [[1,2,3]] has sum 6≤10 but [[1,2],[4,5]] has sum 12>10.

example_3.py — Edge Case

$ Input: grid = [[5]], k = 3

› Output: 0

💡 Note: The only submatrix is [5], but 5 > 3, so no valid submatrices exist.

Constraints

1 ≤ m, n ≤ 1000 (where m = grid.length, n = grid[0].length)
1 ≤ grid[i][j] ≤ 1000
1 ≤ k ≤ 10⁹
All submatrices must include the top-left element grid[0][0]

Visualization

Tap to expand

Understanding the Visualization

Start tracking expenses

Begin with the first expense at position [0,0]

Build running totals

Each cell shows total expenses from top-left to that position

Count valid budgets

Count how many rectangular regions stay within budget k

Key Takeaway

🎯 Key Insight: Prefix sums transform expensive O(m²n²) submatrix sum calculations into O(1) lookups, making the solution optimal at O(m×n) time complexity.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses prefix sum technique to build a cumulative sum matrix in O(m×n) time. Each cell stores the sum of all elements from the top-left corner to that position, enabling instant submatrix sum calculation. The key insight is that we can build prefix sums and count valid submatrices in a single pass, with early termination when sums exceed k.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(m²×n²)	O(1)	For each possible submatrix, calculate sum by iterating through all elements
Prefix Sum (Optimal)	O(m×n)	O(m×n)	Build cumulative sum matrix to calculate any submatrix sum in O(1) time

Brute Force (Triple Nested Loops) — Algorithm Steps

Iterate through all possible bottom-right positions [i,j]
For each position, sum all elements from [0,0] to [i,j]
If sum ≤ k, increment counter
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with [0,0]

Check submatrix containing only grid[0][0]

Expand right

Check submatrix [0,0] to [0,1], recalculate sum

Continue expanding

For each position [i,j], sum all elements from [0,0] to [i,j]

Code -

solution.c — C

#include <stdio.h>

int countSubmatrices(int** grid, int gridSize, int* gridColSize, int k) {
    int m = gridSize, n = gridColSize[0];
    int count = 0;
    
    // Try all possible bottom-right corners
    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 total = 0;
            for (int row = 0; row <= i; row++) {
                for (int col = 0; col <= j; col++) {
                    total += grid[row][col];
                }
            }
            
            // Check if sum is within limit
            if (total <= k) {
                count++;
            } else {
                break; // No point checking further in this row
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²×n²)

m×n iterations for bottom-right corner, each taking O(m×n) time to sum elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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 (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler