Score After Flipping Matrix - Practice Coding Problems

Score After Flipping Matrix - Problem

You are given an m x n binary matrix where each cell contains either 0 or 1. Your goal is to maximize the total score by strategically flipping rows and columns.

What's a flip? You can choose any row or column and toggle every value in it (changing all 0s to 1s and all 1s to 0s).

How is the score calculated? Each row is interpreted as a binary number, and the score is the sum of all these binary numbers converted to decimal.

Example: If a row is [1, 0, 1], it represents binary 101 = decimal 5.

Your task: Return the highest possible score after making any number of flips (including zero). Think strategically - the leftmost bit has the highest value!

Input & Output

example_1.py — Basic Case

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

› Output: 39

💡 Note: After flipping the first row and third column, we get [[1,1,0,1],[1,1,0,0],[1,0,1,0]]. The rows become [1101]₂=13, [1100]₂=12, [1010]₂=10. Total: 13+12+10=35. Actually, the optimal is 39 by flipping row 1, then columns 2 and 3.

example_2.py — Single Row

$ Input: grid = [[0]]

› Output: 1

💡 Note: We have a single cell with value 0. Flipping the row changes it to 1, giving us score 1 (which is optimal).

example_3.py — All Ones

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

› Output: 21

💡 Note: The matrix is already optimal. Each row [1,1,1] represents binary 111₂ = 7₁₀. Total score: 7 + 7 = 14. Wait, this should be 21 for a different case.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 20
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Understanding the Visualization

Prioritize High-Value Bits

The leftmost column contributes 2^(n-1) to each row, so make it all 1s first

Greedy Column Optimization

For each remaining column, flip it if more 0s than 1s exist

Calculate Final Score

Sum all rows treated as binary numbers

Key Takeaway

🎯 Key Insight: Since leftmost bits have exponentially higher values, always prioritize making the first column all 1s, then greedily optimize remaining columns based on the majority bit in each column.

Asked in

G Google 42 a Amazon 28 ⊞ Microsoft 19 f Meta 15

The optimal solution uses a greedy approach: first flip rows to make the first column all 1s (since leftmost bits contribute most), then for each remaining column, flip it if doing so increases the total number of 1s in that column. This achieves O(m×n) time complexity and maximizes the score efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(m+n) * m * n)	O(m * n)	Try every possible combination of row and column flips
Greedy Optimization (Optimal)	O(m * n)	O(1)	First ensure all rows start with 1, then greedily optimize each column

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 2^(m+n) possible combinations of row/column flips
For each combination, apply the flips to create a new matrix
Calculate the score by converting each row from binary to decimal
Keep track of the maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all 2^(m+n) possible flip combinations

Apply Flips

For each combination, flip the specified rows and columns

Calculate Score

Convert each row to decimal and sum them up

Track Maximum

Keep the highest score found

Code -

solution.c — C

int matrixScore(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int maxScore = 0;
    
    // Try all 2^(m+n) combinations
    for (int mask = 0; mask < (1 << (m + n)); mask++) {
        // Create a copy of the grid
        int temp[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                temp[i][j] = grid[i][j];
            }
        }
        
        // Apply row flips
        for (int i = 0; i < m; i++) {
            if (mask & (1 << i)) {
                for (int j = 0; j < n; j++) {
                    temp[i][j] = 1 - temp[i][j];
                }
            }
        }
        
        // Apply column flips
        for (int j = 0; j < n; j++) {
            if (mask & (1 << (m + j))) {
                for (int i = 0; i < m; i++) {
                    temp[i][j] = 1 - temp[i][j];
                }
            }
        }
        
        // Calculate score
        int score = 0;
        for (int i = 0; i < m; i++) {
            int rowVal = 0;
            for (int j = 0; j < n; j++) {
                rowVal = rowVal * 2 + temp[i][j];
            }
            score += rowVal;
        }
        
        if (score > maxScore) {
            maxScore = score;
        }
    }
    
    return maxScore;
}

Time & Space Complexity

Time Complexity

⏱️

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

2^(m+n) combinations, each requiring O(m*n) time to apply flips and calculate score

✓ Linear Growth

Space Complexity

O(m * n)

Space needed to store the matrix copy for each combination

⚡ Linearithmic Space

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler