Count Submatrices With Equal Frequency of X and Y

Count Submatrices With Equal Frequency of X and Y - Problem

You're given a 2D character matrix grid where each cell contains either 'X', 'Y', or '.'. Your task is to find the number of submatrices that satisfy all of the following conditions:

The submatrix must include the top-left corner grid[0][0]
The submatrix contains an equal frequency of 'X' and 'Y' characters
The submatrix contains at least one 'X' character

A submatrix is defined by its bottom-right corner (i, j), where the submatrix includes all cells from (0, 0) to (i, j) inclusive.

Example: If grid[0][0] = 'X' and grid[0][1] = 'Y', then the submatrix ending at (0, 1) has 1 'X' and 1 'Y', satisfying our conditions.

Input & Output

example_1.py — Basic balanced submatrix

$ Input: grid = [["X","Y"],["Y","X"]]

› Output: 2

💡 Note: Two valid submatrices: (0,0)→(0,1) with 1 X and 1 Y, and (0,0)→(1,1) with 2 X's and 2 Y's

example_2.py — Single cell case

$ Input: grid = [["X"]]

› Output: 0

💡 Note: Only one submatrix (0,0)→(0,0) with 1 X and 0 Y's - not balanced, so result is 0

example_3.py — Mixed with dots

$ Input: grid = [["X",".","Y"],[".","Y","X"]]

› Output: 1

💡 Note: Only the full submatrix (0,0)→(1,2) has balanced counts: 2 X's and 2 Y's

Visualization

Tap to expand

Understanding the Visualization

Build counting tables

Create cumulative count tables for treasures (X) and traps (Y)

Evaluate regions

For each possible rectangular region starting from origin, check balance

Apply criteria

Count regions where treasures equal traps and at least one treasure exists

Report findings

Return the total count of viable expedition regions

Key Takeaway

🎯 Key Insight: Prefix sums transform an O(m²×n²) brute force solution into an elegant O(m×n) algorithm by precomputing cumulative counts, enabling instant submatrix queries.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

O(m×n) to build prefix sums + O(m×n) to check all endpoints

✓ Linear Growth

Space Complexity

O(m × n)

Two prefix sum arrays of size m×n for X and Y counts

⚡ Linearithmic Space

Constraints

1 ≤ grid.length, grid[i].length ≤ 100
grid[i][j] is either 'X', 'Y', or '.'
The submatrix must contain grid[0][0]
At least one 'X' must be present in valid submatrices

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal approach uses 2D prefix sums to precompute cumulative counts of 'X' and 'Y' characters. This allows us to query the count of any character in any submatrix starting from (0,0) in O(1) time. We build the prefix arrays in O(m×n) time, then check all possible endpoints in O(m×n) time, giving us an overall O(m×n) solution with O(m×n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(m² × n²)	O(1)	Check every possible submatrix starting from (0,0) by counting characters from scratch
Prefix Sum Optimization (Optimal)	O(m × n)	O(m × n)	Use 2D prefix sums to calculate character counts in O(1) time for each submatrix

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all possible bottom-right corners (i,j)
For each (i,j), scan the entire submatrix from (0,0) to (i,j)
Count occurrences of 'X' and 'Y' in the current submatrix
Check if count_X == count_Y and count_X > 0
Increment result counter if conditions are met

Visualization

Tap to expand

Step-by-Step Walkthrough

Select endpoint (i,j)

Choose bottom-right corner of submatrix

Scan entire submatrix

Count X's and Y's from (0,0) to (i,j)

Check conditions

Verify equal counts and at least one X

Repeat for all endpoints

Continue for all possible (i,j) pairs

Code -

solution.c — C

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

int numSubmatrixSumTarget(char** grid, int m, int n) {
    if (m == 0 || n == 0) return 0;
    
    int result = 0;
    
    // Try all possible bottom-right corners
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int countX = 0, countY = 0;
            
            // Count X's and Y's in submatrix from (0,0) to (i,j)
            for (int r = 0; r <= i; r++) {
                for (int c = 0; c <= j; c++) {
                    if (grid[r][c] == 'X') {
                        countX++;
                    } else if (grid[r][c] == 'Y') {
                        countY++;
                    }
                }
            }
            
            // Check if conditions are met
            if (countX == countY && countX > 0) {
                result++;
            }
        }
    }
    
    return result;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × n²)

For each of the m×n possible endpoints, we scan up to m×n cells

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

1 ≤ grid.length, grid[i].length ≤ 100
grid[i][j] is either 'X', 'Y', or '.'
The submatrix must contain grid[0][0]
At least one 'X' must be present in valid submatrices

29.2K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler