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

You are given an m x n binary matrix grid. A row or column is considered palindromic if its values read the same forward and backward.

You can flip any number of cells in grid from 0 to 1, or from 1 to 0.

Return the minimum number of cells that need to be flipped to make all rows and columns palindromic, and the total number of 1's in grid divisible by 4.

Input & Output

Example 1 — Basic 2x2 Grid

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

› Output: 2

💡 Note: Grid is already palindromic but has 2 ones. Need 2 more ones for divisibility by 4, so flip both 0s to 1s.

Example 2 — Single Row

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

› Output: 0

💡 Note: Row [1,0,0,1] is palindromic, column palindromes are trivial (single element), and 2 ones is not divisible by 4. But since columns are trivial, we need 2 more 1s, making total 4, requiring 2 flips. Actually, need to recalculate - this would need 2 flips to make 4 ones total.

Example 3 — All Zeros

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

› Output: 0

💡 Note: Already palindromic and 0 ones is divisible by 4, so no flips needed.

Constraints

1 ≤ m, n ≤ 1000
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is to group symmetric positions that must have the same value for palindrome property. For each group, choose the majority value to minimize flips, then adjust for divisibility by 4. Best approach uses position grouping with Time: O(m×n), Space: O(m×n).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^(m*n) * (m+n)) Space: O(m*n)

Generate all possible grid states by flipping cells, then check if all rows and columns are palindromic and total 1s divisible by 4. This explores the entire solution space.

Optimized - Group Symmetric Positions

⏱️ Time: O(m * n) Space: O(m * n)

Identify groups of cells that must be equal for both row and column palindromes. For each group, choose the value (0 or 1) that minimizes flips, then adjust for divisibility by 4.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^(m*n) possible grid states
For each state, check palindrome condition for all rows and columns
Check if total 1s is divisible by 4
Track minimum flips needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate States

Create all 2^(m*n) possible grid configurations

Check Palindromes

Verify each state has palindromic rows and columns

Count Divisibility

Ensure total 1s is divisible by 4

Find Minimum

Track minimum flips among valid states

Code -

solution.c — C

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

int m, n;

int isPalindromic(int* grid) {
    // Check all rows
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n / 2; j++) {
            if (grid[i * n + j] != grid[i * n + (n - 1 - j)]) return 0;
        }
    }
    // Check all columns
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < m / 2; i++) {
            if (grid[i * n + j] != grid[(m - 1 - i) * n + j]) return 0;
        }
    }
    return 1;
}

int isDivisibleBy4(int* grid) {
    int ones = 0;
    for (int i = 0; i < m * n; i++)
        ones += grid[i];
    return ones % 4 == 0;
}

int countBits(int mask) {
    int count = 0;
    while (mask) {
        count += mask & 1;
        mask >>= 1;
    }
    return count;
}

int minFlips(int** mat) {
    int total = m * n;
    int totalCombinations = (1 << total);
    int minFound = INT_MAX;

    // Flatten original grid
    int original[20];
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++)
            original[i * n + j] = mat[i][j];

    // Try all combinations
    for (int mask = 0; mask < totalCombinations; mask++) {
        int flips = countBits(mask);
        if (flips >= minFound) continue;

        // Apply mask to get new grid
        int newGrid[20];
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {
                int pos = i * n + j;
                newGrid[pos] = original[pos] ^ ((mask >> pos) & 1);
            }

        // Check if valid
        if (isPalindromic(newGrid) && isDivisibleBy4(newGrid)) {
            minFound = flips;
        }
    }

    return minFound == INT_MAX ? -1 : minFound;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);

    input[strcspn(input, "\n")] = 0;

    int numbers[100];
    int numCount = 0;
    char* p = input;
    while (*p) {
        if (*p >= '0' && *p <= '9') {
            numbers[numCount] = *p - '0';
            numCount++;
        }
        p++;
    }

    int rows = 0;
    p = input;
    int foundFirst = 0;
    while (*p) {
        if (*p == '[') {
            if (!foundFirst) {
                foundFirst = 1;
            } else {
                rows++;
            }
        }
        p++;
    }

    int cols = numCount / rows;

    m = rows;
    n = cols;

    int** mat = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        mat[i] = (int*)malloc(cols * sizeof(int));
    }

    int idx = 0;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            mat[i][j] = numbers[idx++];

    int result = minFlips(mat);
    printf("%d\n", result);

    for (int i = 0; i < rows; i++)
        free(mat[i]);
    free(mat);

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m*n) * (m+n))

2^(m*n) possible states, each requiring O(m+n) palindrome checks

✓ Linear Growth

Space Complexity

O(m*n)

Store grid state and track best solution

⚡ Linearithmic Space

8.9K Views

Medium Frequency

~25 min Avg. Time

245 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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler