Minimum Number of Flips to Make Binary Grid Palindromic I

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

You are given an m x n binary matrix grid where each cell contains either 0 or 1. Your goal is to make the entire grid follow a palindromic pattern by flipping the minimum number of cells.

A palindromic pattern means that either:

All rows are palindromic (each row reads the same forwards and backwards), OR
All columns are palindromic (each column reads the same top-to-bottom and bottom-to-top)

You can flip any cell from 0 to 1 or from 1 to 0. Return the minimum number of flips needed to achieve one of these two palindromic arrangements.

Example: For matrix [[1,0,0],[0,1,0],[1,1,1]], you need to choose between making all rows palindromic or all columns palindromic, whichever requires fewer flips.

Input & Output

example_1.py — Basic Grid

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

› Output: 1

💡 Note: To make all rows palindromic: Row 1 needs 1 flip (1,0,0 → 1,0,1 or 0,0,0), Row 2 is already palindromic, Row 3 is already palindromic. Total: 1 flip. To make all columns palindromic: Column 1 needs 0 flips (already palindromic), Column 2 needs 1 flip, Column 3 needs 0 flips. Total: 1 flip. Minimum is 1.

example_2.py — Single Row

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

› Output: 1

💡 Note: For a single row grid, we compare row vs column costs. Row: 1 flip needed to make [1,0,1,0,1] palindromic. Columns: Each column has only 1 element (already palindromic), so 0 flips total. Minimum is 0 flips (choose columns).

example_3.py — Already Palindromic

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

› Output: 0

💡 Note: This grid is already palindromic both row-wise and column-wise. Row analysis: all rows are palindromes (0 flips). Column analysis: all columns are palindromes (0 flips). Minimum is 0.

Visualization

Tap to expand

Understanding the Visualization

Analyze Rows

Count how many flips needed to make each row read the same forwards and backwards

Analyze Columns

Count how many flips needed to make each column read the same top-to-bottom and bottom-to-top

Choose Strategy

Pick the approach (row or column) that requires fewer total flips

Return Result

Output the minimum number of flips needed

Key Takeaway

🎯 Key Insight: We don't need to find the globally optimal solution - just compare two strategies (all rows vs all columns palindromic) and pick the cheaper one!

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

We visit each cell exactly twice - once during row analysis and once during column analysis

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointer variables and counters

✓ Linear Space

Constraints

1 ≤ m, n ≤ 300
grid[i][j] is either 0 or 1
Time limit: 2 seconds
Space limit: 256 MB

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal approach uses two pointers to efficiently check palindrome property for both rows and columns. We calculate the minimum flips needed to make all rows palindromic, then calculate the same for all columns, and return the minimum of these two values. Time complexity is O(m×n) and space complexity is O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Optimization	O(m*n)	O(1)	Use two pointers from opposite ends to efficiently count mismatches in each row and column
Brute Force (Direct Comparison)	O(m*n)	O(1)	Calculate cost for making all rows palindromic, then all columns palindromic, return minimum

Two Pointers Optimization — Algorithm Steps

For each row, place left pointer at start and right pointer at end
Move pointers inward while left < right, counting mismatches
Apply the same two-pointer technique for each column (top and bottom pointers)
Each mismatch represents one flip needed to make that row/column palindromic
Return minimum of total row flips and total column flips

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Place left and right pointers at opposite ends of each row

Compare & Move

Compare values at pointer positions and move them toward center

Count Mismatches

Increment flip counter when values don't match

Repeat for Columns

Apply same logic with top and bottom pointers for columns

Choose Minimum

Select the approach requiring fewer total flips

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int countRowFlips(int** grid, int m, int n) {
    int totalFlips = 0;
    for (int i = 0; i < m; i++) {
        int left = 0, right = n - 1;
        while (left < right) {
            if (grid[i][left] != grid[i][right]) {
                totalFlips++;
            }
            left++;
            right--;
        }
    }
    return totalFlips;
}

int countColFlips(int** grid, int m, int n) {
    int totalFlips = 0;
    for (int j = 0; j < n; j++) {
        int top = 0, bottom = m - 1;
        while (top < bottom) {
            if (grid[top][j] != grid[bottom][j]) {
                totalFlips++;
            }
            top++;
            bottom--;
        }
    }
    return totalFlips;
}

int minFlips(int** grid, int m, int n) {
    return min(countRowFlips(grid, m, n), countColFlips(grid, m, n));
}

int main() {
    int** grid = (int**)malloc(3 * sizeof(int*));
    for (int i = 0; i < 3; i++) {
        grid[i] = (int*)malloc(3 * sizeof(int));
    }
    grid[0][0] = 1; grid[0][1] = 0; grid[0][2] = 0;
    grid[1][0] = 0; grid[1][1] = 1; grid[1][2] = 0;
    grid[2][0] = 1; grid[2][1] = 1; grid[2][2] = 1;
    
    printf("%d\n", minFlips(grid, 3, 3));
    
    for (int i = 0; i < 3; i++) {
        free(grid[i]);
    }
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

We visit each cell exactly twice - once during row analysis and once during column analysis

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointer variables and counters

✓ Linear Space

Constraints

1 ≤ m, n ≤ 300
grid[i][j] is either 0 or 1
Time limit: 2 seconds
Space limit: 256 MB

28.4K Views

Medium Frequency

~15 min Avg. Time

945 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

Two Pointers Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler