Minimum Number of Flips to Make Binary Grid Palindromic II

Minimum Number of Flips to Make Binary Grid Palindromic II - Problem

Transform a Binary Grid into Perfect Palindromic Harmony

You are given an m × n binary matrix grid containing only 0s and 1s. Your mission is to transform this grid to satisfy two challenging conditions simultaneously:

📚 Palindromic Perfection: Every row and every column must read the same forwards and backwards (palindromic)
🔢 Divisibility Rule: The total count of 1s in the entire grid must be divisible by 4

You can flip any cell from 0 to 1 or from 1 to 0. Each flip counts as one operation.

Goal: Return the minimum number of flips needed to achieve both conditions.

Example:
[[1,0,0],[0,1,0],[0,0,1]] → Minimum flips needed to make all rows/columns palindromic AND total 1s divisible by 4.

Input & Output

example_1.py — Small Grid

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

› Output: 3

💡 Note: Need to make rows and columns palindromic AND total 1s divisible by 4. Current grid has 3 ones. To make palindromic: (0,0)=1 must equal (0,2)=0 and (2,0)=0 must equal (2,2)=1, etc. Optimal solution flips 3 cells to achieve both conditions.

example_2.py — Symmetric Grid

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

› Output: 0

💡 Note: This grid is already palindromic in all rows and columns: [0,1,0] reads same forwards/backwards, and column [0,1,0] also palindromic. Total 1s = 4, which is divisible by 4. No flips needed.

example_3.py — Edge Case

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

› Output: 0

💡 Note: All rows [1,1] and columns [1,1] are already palindromic. Total 1s = 4, divisible by 4. Perfect as-is, 0 flips needed.

Constraints

1 ≤ m, n ≤ 1000
grid[i][j] is either 0 or 1
m × n ≤ 10⁶ (total cells limited)
Solution must satisfy both palindromic AND divisibility conditions

Asked in

The optimal approach uses symmetry group analysis to identify cells that must have identical values due to palindrome constraints. By grouping symmetric cells and optimizing each group independently, we achieve O(m×n) time complexity. The key insight is handling the divisibility by 4 constraint by adjusting group assignments when needed.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(m×n) × (m×n))	O(m×n)	Generate all possible grid configurations and find the one with minimum flips
Symmetry Analysis with Grouping	O(m×n)	O(m×n)	Group cells that must have same value due to palindrome constraints, then optimize each group

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^(m×n) possible binary matrices
For each configuration, check if all rows and columns are palindromic
Check if total count of 1s is divisible by 4
Calculate flips needed from original grid
Track minimum flips across all valid configurations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Configuration

Create binary grid from current mask

Check Rows

Verify each row is palindromic

Check Columns

Verify each column is palindromic

Count Ones

Check if total 1s divisible by 4

Calculate Flips

Count differences from original grid

Code -

solution.c — C

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

int isPalindromic(int* arr, int len) {
    for (int i = 0; i < len / 2; i++) {
        if (arr[i] != arr[len - 1 - i]) return 0;
    }
    return 1;
}

int countFlips(int** original, int** target, int m, int n) {
    int count = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (original[i][j] != target[i][j]) count++;
        }
    }
    return count;
}

int minFlips(int** grid, int m, int n) {
    int minFlips = INT_MAX;
    
    // Try all 2^(m*n) configurations
    for (long long mask = 0; mask < (1LL << (m * n)); mask++) {
        int** config = malloc(m * sizeof(int*));
        for (int i = 0; i < m; i++) {
            config[i] = calloc(n, sizeof(int));
        }
        int onesCount = 0;
        
        // Generate configuration from mask
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int bitPos = i * n + j;
                if (mask & (1LL << bitPos)) {
                    config[i][j] = 1;
                    onesCount++;
                }
            }
        }
        
        // Check palindromic condition
        int valid = 1;
        
        // Check all rows
        for (int i = 0; i < m && valid; i++) {
            if (!isPalindromic(config[i], n)) valid = 0;
        }
        
        // Check all columns
        for (int j = 0; j < n && valid; j++) {
            int* col = malloc(m * sizeof(int));
            for (int i = 0; i < m; i++) col[i] = config[i][j];
            if (!isPalindromic(col, m)) valid = 0;
            free(col);
        }
        
        // Check divisibility by 4 and update minimum
        if (valid && onesCount % 4 == 0) {
            int flips = countFlips(grid, config, m, n);
            if (flips < minFlips) minFlips = flips;
        }
        
        // Clean up
        for (int i = 0; i < m; i++) free(config[i]);
        free(config);
    }
    
    return minFlips;
}

int main() {
    printf("Brute force approach - too slow for practical use\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m×n) × (m×n))

2^(m×n) configurations to check, each requiring O(m×n) time to validate palindromes and count differences

✓ Linear Growth

Space Complexity

O(m×n)

Space to store the current configuration being tested

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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