Equal Sum Grid Partition I - Practice Coding Problems

Equal Sum Grid Partition I - Problem

Equal Sum Grid Partition

Imagine you're a data analyst working with a financial spreadsheet filled with positive transaction amounts. Your task is to determine if you can make exactly one cut - either horizontal (splitting rows) or vertical (splitting columns) - such that the sum of numbers on both sides of the cut is perfectly balanced.

Given an m × n matrix grid of positive integers, return true if such a partition exists, otherwise return false.

Key Requirements:
• Make exactly one cut (horizontal OR vertical, not both)
• Both resulting sections must be non-empty
• The sum of elements in both sections must be equal

Example: In a 3×3 grid, a vertical cut between columns 1 and 2 creates a left section (column 0) and right section (columns 1-2). If their sums are equal, return true!

Input & Output

example_1.py — Basic Equal Partition

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

› Output: true

💡 Note: A vertical cut between columns 1 and 2 creates left section with sum 6 (2 columns × 3 rows × 1) and right section with sum 6 (2 columns × 3 rows × 1). Since 6 = 6, return true.

example_2.py — No Valid Partition

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

› Output: false

💡 Note: Total sum = 10. Horizontal cut: top=3, bottom=7 (3≠7). Vertical cut: left=4, right=6 (4≠6). No cut creates equal partitions.

example_3.py — Single Row Matrix

$ Input: grid = [[2,4,2,8]]

› Output: true

💡 Note: Only vertical cuts possible. Cut between columns 1 and 2: left=[2,4]=6, right=[2,8]=10 (no). Cut between columns 2 and 3: left=[2,4,2]=8, right=[8]=8. Since 8=8, return true.

Visualization

Tap to expand

Understanding the Visualization

Check Total Calories

Count all calories - if odd number, impossible to split equally

Try Horizontal Breaks

Test breaking between each row, using running total of calories above the break

Try Vertical Breaks

Test breaking between each column, using running total of calories to the left

Find Equal Split

When running total equals exactly half the total calories, we found our break point!

Key Takeaway

🎯 Key Insight: Use running sums instead of recalculating from scratch - this reduces time complexity from O(m²n + mn²) to O(mn)

Time & Space Complexity

Time Complexity

⏱️

O(mn)

O(mn) to calculate total sum and prefix sums + O(m+n) to check all cut positions

✓ Linear Growth

Space Complexity

O(m+n)

O(m) for row prefix sums + O(n) for column prefix sums

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 1000
1 ≤ grid[i][j] ≤ 10⁶
Matrix contains only positive integers
Both resulting sections after cut must be non-empty

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses prefix sums to achieve O(mn) time complexity. First calculate the total sum - if odd, return false immediately. Then use running totals to check each horizontal and vertical cut position in O(1) time. The key insight is that we only need to track the sum of one section since the other equals total - current_section.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum (Optimal)	O(mn)	O(m+n)	Use prefix sums to calculate any section sum in O(1) time
Brute Force (Nested Loops)	O(m²n + mn²)	O(1)	Try every possible cut and calculate sums from scratch each time

Prefix Sum (Optimal) — Algorithm Steps

Calculate the total sum of the entire matrix
If total sum is odd, return false immediately (can't split evenly)
Compute prefix sums for each row to enable fast horizontal cuts
For each possible horizontal cut, use prefix sums to check if top = bottom = total/2
Compute prefix sums for each column to enable fast vertical cuts
For each possible vertical cut, use prefix sums to check if left = right = total/2

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Total

Sum entire matrix: total = 21, target = 10.5 (impossible)

Running Row Sum

Add row by row: 6, then 15 - check if equals target after each row

Running Column Sum

Add column by column: 5, then 10, then 15 - found target!

Cut Found

Vertical cut after column 1 creates equal partitions

Code -

solution.c — C

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

bool canPartition(int** grid, int m, int n) {
    // Calculate total sum
    long long totalSum = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            totalSum += grid[i][j];
        }
    }
    
    // If total is odd, can't partition equally
    if (totalSum % 2 != 0) return false;
    
    long long target = totalSum / 2;
    
    // Check horizontal cuts
    long long currentSum = 0;
    for (int i = 0; i < m - 1; i++) {
        for (int j = 0; j < n; j++) {
            currentSum += grid[i][j];
        }
        if (currentSum == target) return true;
    }
    
    // Check vertical cuts
    currentSum = 0;
    for (int j = 0; j < n - 1; j++) {
        for (int i = 0; i < m; i++) {
            currentSum += grid[i][j];
        }
        if (currentSum == target) return true;
    }
    
    return false;
}

int main() {
    int m = 3, n = 4;
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            grid[i][j] = 1;
        }
    }
    printf("%s\n", canPartition(grid, m, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

O(mn) to calculate total sum and prefix sums + O(m+n) to check all cut positions

✓ Linear Growth

Space Complexity

O(m+n)

O(m) for row prefix sums + O(n) for column prefix sums

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 1000
1 ≤ grid[i][j] ≤ 10⁶
Matrix contains only positive integers
Both resulting sections after cut must be non-empty

28.5K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler