Find Sorted Submatrices With Maximum Element at Most K

Find Sorted Submatrices With Maximum Element at Most K - Problem

🎯 Find Sorted Submatrices With Maximum Element at Most K

Imagine you're a data analyst working with a 2D grid of numbers, and you need to identify specific rectangular regions that meet strict criteria. Your task is to count how many submatrices satisfy two important conditions:

🔢 The maximum element in the submatrix is ≤ k
📉 Each row in the submatrix is sorted in non-increasing order (descending)

A submatrix is any rectangular region you can select from the grid by choosing coordinates (x1, y1) as the top-left corner and (x2, y2) as the bottom-right corner, where all cells grid[x][y] with x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2 are included.

Example: For grid [[7,6,3],[7,6,3]] with k=6, the submatrix from (0,1) to (1,2) containing [[6,3],[6,3]] is valid because:

Maximum element is 6 ≤ k
Both rows [6,3] and [6,3] are in non-increasing order

Return the total count of all such valid submatrices.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Valid submatrices: [[6]], [[3]], [[6,3]], and [[6,3],[6,3]]. All satisfy max ≤ k and non-increasing rows.

example_2.py — Single Row

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

› Output: 2

💡 Note: Only [[3]] and [[6,3]] are valid. [7] and [7,6] have elements > k.

example_3.py — No Valid Submatrices

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

› Output: 3

💡 Note: Valid submatrices are [[1]], [[2]], and single cell submatrices with value ≤ 2. Rows are not properly sorted.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Setup Inspection

Examine rectangular sections of chocolate trays

Check Sweetness

Ensure no chocolate exceeds sweetness limit k

Verify Arrangement

Confirm each row goes from sweetest to least sweet

Count Valid Sections

Tally all sections meeting both criteria

Key Takeaway

🎯 Key Insight: By treating each row as a base for building histograms and using monotonic stacks, we efficiently count all valid rectangular regions without redundant checking.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 31

The optimal solution uses a monotonic stack approach with O(m²n) time complexity. Transform the 2D problem into multiple 1D histogram problems by calculating heights of valid non-increasing sequences. For each starting row, build heights representing sequence lengths and use monotonic stack to efficiently count all possible rectangles, similar to the largest rectangle in histogram problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Submatrices)	O(m²n³)	O(1)	Check every possible submatrix for both conditions
Monotonic Stack (Optimal)	O(m²n)	O(n)	Use monotonic stack to efficiently count valid submatrices by treating it as largest rectangle problem

Brute Force (Check All Submatrices) — Algorithm Steps

Iterate through all possible top-left corners (r1, c1)
For each top-left, iterate through all possible bottom-right corners (r2, c2)
For the current submatrix, check if all rows are non-increasing
Find the maximum element in the submatrix
If both conditions are met, increment the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Top-Left

Choose top-left corner (r1, c1)

Select Bottom-Right

Choose bottom-right corner (r2, c2)

Check Rows

Verify each row is non-increasing

Check Maximum

Find max element ≤ k

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>
#define max(a,b) ((a) > (b) ? (a) : (b))

bool isValidSubmatrix(int** grid, int r1, int c1, int r2, int c2, int k) {
    int maxVal = 0;
    
    for (int r = r1; r <= r2; r++) {
        int prev = 1000000;
        for (int c = c1; c <= c2; c++) {
            if (grid[r][c] > prev) return false;
            prev = grid[r][c];
            maxVal = max(maxVal, grid[r][c]);
        }
    }
    
    return maxVal <= k;
}

int countSubmatrices(int** grid, int gridSize, int* gridColSize, int k) {
    int m = gridSize, n = gridColSize[0];
    int count = 0;
    
    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++) {
                    if (isValidSubmatrix(grid, r1, c1, r2, c2, k)) {
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n³)

Four nested loops for coordinates plus O(n) to check each submatrix

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

29.6K Views

Medium Frequency

~32 min Avg. Time

847 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

🎯 Find Sorted Submatrices With Maximum Element at Most K

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Submatrices) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler