Minimum Number of Flips to Make Binary Grid Palindromic I - 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 either all rows palindromic or all columns palindromic.

Input & Output

Example 1 — Already Palindromic Rows

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

› Output: 0

💡 Note: All rows are already palindromic: [1,0,1] reads same forward/backward, [0,1,0] reads same forward/backward. No flips needed.

Example 2 — Need Column Flips

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

› Output: 2

💡 Note: Rows need 2 flips: [1,0]→[1,1] (1 flip) and [0,1]→[0,0] (1 flip). Columns need 2 flips: change grid[0][0] or grid[1][0] to make column 0 palindromic (1 flip), and change grid[0][1] or grid[1][1] to make column 1 palindromic (1 flip). Both approaches need 2 flips: min(2,2) = 2.

Example 3 — Single Column

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

› Output: 1

💡 Note: Rows are already palindromic (single elements). Column [1,0,1] needs 0 flips (already palindromic). But we have rows that need flips. Actually, single elements are palindromic, so answer is 0 for rows, 0 for column. min(0,0) = 0. Wait, let me recalculate: all single-element rows are palindromic, column [1,0,1] is palindromic. Answer is 0.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 300
0 ≤ grid[i][j] ≤ 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that we only need to choose between making ALL rows palindromic OR ALL columns palindromic, not both. Use two pointers to count mismatched pairs in each row/column. Best approach: Two Pointers - Time: O(m×n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Possibilities

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

Try every possible combination of 0s and 1s in the grid, then check if all rows are palindromic or all columns are palindromic. This approach explores the entire solution space.

Two Pointers - Count Mismatches

⏱️ Time: O(m × n) Space: O(1)

Calculate the cost to make all rows palindromic by counting mismatches in each row using two pointers from ends. Then calculate the cost for columns. Return the minimum of these two costs.

Brute Force - Try All Possibilities — Algorithm Steps

Generate all 2^(m*n) possible grids
For each grid, check if all rows are palindromic
For each grid, check if all columns are palindromic
Return minimum flips needed from valid grids

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Configuration

Create grid based on binary mask

Count Flips

Compare with original grid

Check Palindromic

Test if rows or columns are palindromic

Code -

solution.c — C

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

int solution(int** grid, int m, int n) {
    // Calculate flips needed to make all rows palindromic
    int rowFlips = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n / 2; j++) {
            if (grid[i][j] != grid[i][n - 1 - j]) {
                rowFlips++;
            }
        }
    }
    
    // Calculate flips needed to make all columns palindromic
    int colFlips = 0;
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < m / 2; i++) {
            if (grid[i][j] != grid[m - 1 - i][j]) {
                colFlips++;
            }
        }
    }
    
    // Return minimum of the two approaches
    return (rowFlips < colFlips) ? rowFlips : colFlips;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Parse JSON input like [[1,0,1],[0,1,0]]
    int m = 0, n = 0;
    
    // Count rows and columns
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    if (*ptr) ptr++; // Skip first '['
    
    // Count rows by counting '[' after the first one
    char* temp = ptr;
    while (*temp) {
        if (*temp == '[') {
            m++;
            if (n == 0) {
                // Count elements in first row
                temp++;
                while (*temp && *temp != ']') {
                    if (*temp >= '0' && *temp <= '9') {
                        n++;
                        while (*temp >= '0' && *temp <= '9') temp++;
                    } else {
                        temp++;
                    }
                }
            }
        }
        temp++;
    }
    
    if (m == 0 || n == 0) {
        printf("0\n");
        return 0;
    }
    
    // Allocate grid
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Parse the actual values
    ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    if (*ptr) ptr++; // Skip first '['
    
    int row = 0, col = 0;
    while (*ptr && row < m) {
        if (*ptr == '[') {
            ptr++; // Skip '['
            col = 0;
            while (*ptr && *ptr != ']' && col < n) {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[row][col] = *ptr - '0';
                    col++;
                }
                ptr++;
            }
            if (*ptr == ']') ptr++; // Skip ']'
            row++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(grid, m, n);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

Generate 2^(m*n) grids, check each takes O(m*n) time

✓ Linear Growth

Space Complexity

O(m × n)

Store the current grid configuration

⚡ Linearithmic Space

8.4K Views

Medium Frequency

~15 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 I - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Possibilities — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler