Equal Sum Grid Partition II

Equal Sum Grid Partition II - Problem

Array Hash Table Matrix Enumeration Prefix Sum Hard

You are given an m x n matrix grid of positive integers. Your task is to determine if it is possible to make either one horizontal or one vertical cut on the grid such that:

Each of the two resulting sections formed by the cut is non-empty
The sum of elements in both sections is equal, or can be made equal by discounting at most one single cell in total (from either section)
If a cell is discounted, the rest of the section must remain connected

Return true if such a partition exists; otherwise, return false.

Note: A section is connected if every cell in it can be reached from any other cell by moving up, down, left, or right through other cells in the section.

Input & Output

Example 1 — Vertical Cut with Cell Removal

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

› Output: true

💡 Note: Cut vertically between columns 1 and 2. Left sum = 4, right sum = 4. Already equal, so return true.

Example 2 — Horizontal Cut with Balancing

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

› Output: true

💡 Note: Cut horizontally between rows. Top sum = 3, bottom sum = 7. Remove cell with value 4, making bottom sum 3. Both sections remain connected.

Example 3 — No Valid Partition

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

› Output: false

💡 Note: No single horizontal or vertical cut can create balanced sections, even with one cell removal.

Constraints

2 ≤ m, n ≤ 100
1 ≤ grid[i][j] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to try all possible horizontal and vertical cuts, then check if the resulting sections can be balanced by removing at most one cell while maintaining connectivity. The prefix sum optimization significantly reduces time complexity by enabling O(1) range sum calculations. Best approach uses prefix sums with connectivity verification. Time: O(mn×(m+n)), Space: O(mn).

Common Approaches

✓ Brute Force

⏱️ Time: O(m²n² × (m+n)) Space: O(mn)

For each possible horizontal and vertical cut position, calculate the sum of both sections and check if they're equal or can be made equal by removing one cell while maintaining connectivity.

Prefix Sum Optimization

⏱️ Time: O(mn × (m+n)) Space: O(mn)

Pre-calculate prefix sums to avoid recalculating section sums for each cut. This reduces the time complexity significantly while maintaining the same logic for balancing and connectivity checks.

Brute Force — Algorithm Steps

Step 1: Try each horizontal cut position between rows
Step 2: Calculate sum of top and bottom sections
Step 3: Check if equal or can be balanced by removing one cell
Step 4: Verify connectivity after cell removal
Step 5: Repeat for vertical cuts between columns

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Cut

Test horizontal/vertical cut position

Calculate Sums

Sum elements in both sections

Check Balance

See if equal or can remove one cell

Verify Connectivity

Ensure sections remain connected

Code -

solution.c — C

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

int grid[100][100];
int m, n;
bool visited[100][100];

int getSum(int r1, int c1, int r2, int c2) {
    int total = 0;
    for (int i = r1; i <= r2; i++) {
        for (int j = c1; j <= c2; j++) {
            total += grid[i][j];
        }
    }
    return total;
}

void dfs(int r, int c, int r1, int c1, int r2, int c2, int skipR, int skipC) {
    if (r < r1 || r > r2 || c < c1 || c > c2 || visited[r][c]) return;
    if (r == skipR && c == skipC) return;
    visited[r][c] = true;
    dfs(r+1, c, r1, c1, r2, c2, skipR, skipC);
    dfs(r-1, c, r1, c1, r2, c2, skipR, skipC);
    dfs(r, c+1, r1, c1, r2, c2, skipR, skipC);
    dfs(r, c-1, r1, c1, r2, c2, skipR, skipC);
}

bool isConnected(int r1, int c1, int r2, int c2, int skipR, int skipC) {
    if (r1 > r2 || c1 > c2) return false;
    
    memset(visited, false, sizeof(visited));
    
    bool startFound = false;
    for (int i = r1; i <= r2 && !startFound; i++) {
        for (int j = c1; j <= c2; j++) {
            if (i != skipR || j != skipC) {
                dfs(i, j, r1, c1, r2, c2, skipR, skipC);
                startFound = true;
                break;
            }
        }
    }
    
    for (int i = r1; i <= r2; i++) {
        for (int j = c1; j <= c2; j++) {
            if ((i != skipR || j != skipC) && !visited[i][j]) {
                return false;
            }
        }
    }
    return true;
}

bool canBalance(int sum1, int sum2, int r1, int c1, int r2, int c2, int r3, int c3, int r4, int c4) {
    if (sum1 == sum2) return true;
    
    int diff = abs(sum1 - sum2);
    
    if (sum1 > sum2) {
        for (int i = r1; i <= r2; i++) {
            for (int j = c1; j <= c2; j++) {
                if (grid[i][j] == diff && isConnected(r1, c1, r2, c2, i, j)) {
                    return true;
                }
            }
        }
    }
    
    if (sum2 > sum1) {
        for (int i = r3; i <= r4; i++) {
            for (int j = c3; j <= c4; j++) {
                if (grid[i][j] == diff && isConnected(r3, c3, r4, c4, i, j)) {
                    return true;
                }
            }
        }
    }
    
    return false;
}

bool solution() {
    // Try horizontal cuts
    for (int cutRow = 0; cutRow < m - 1; cutRow++) {
        int sumTop = getSum(0, 0, cutRow, n - 1);
        int sumBottom = getSum(cutRow + 1, 0, m - 1, n - 1);
        if (canBalance(sumTop, sumBottom, 0, 0, cutRow, n - 1, cutRow + 1, 0, m - 1, n - 1)) {
            return true;
        }
    }
    
    // Try vertical cuts
    for (int cutCol = 0; cutCol < n - 1; cutCol++) {
        int sumLeft = getSum(0, 0, m - 1, cutCol);
        int sumRight = getSum(0, cutCol + 1, m - 1, n - 1);
        if (canBalance(sumLeft, sumRight, 0, 0, m - 1, cutCol, 0, cutCol + 1, m - 1, n - 1)) {
            return true;
        }
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small test cases
    char *p = line + 1; // Skip first '['
    m = 0;
    while (*p && *p != ']') {
        if (*p == '[') {
            p++;
            n = 0;
            while (*p && *p != ']') {
                if (*p >= '0' && *p <= '9') {
                    grid[m][n] = 0;
                    while (*p >= '0' && *p <= '9') {
                        grid[m][n] = grid[m][n] * 10 + (*p - '0');
                        p++;
                    }
                    n++;
                }
                if (*p == ',') p++;
            }
            m++;
        }
        p++;
    }
    
    bool result = solution();
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n² × (m+n))

For each of O(m+n) cuts, we calculate sums O(mn), try removing each cell O(mn), and check connectivity O(mn)

✓ Linear Growth

Space Complexity

O(mn)

DFS recursion stack and visited array for connectivity checks

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~35 min Avg. Time

284 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler