# Maximize 1s after Flipping exactly one row and one column in given Binary Matrix

• Difficulty Level : Medium
• Last Updated : 25 Mar, 2022

Given a binary matrix mat[][]. The task is to find the maximum 1’s that can be obtained after flipping all the elements of exactly one row followed by flipping all elements of exactly one column.

Example:

Input: mat[][]  = {{1, 0, 1}, {0, 1, 0}, {1, 0, 0}}
Output: 8
Explanation: Flip row 1 to get:
{{1, 0, 1},
{1, 0, 1},
{1, 0, 0}}
And then flip column 1 to get:
{{1, 1, 1},
{1, 1, 1},
{1, 1, 0}}

Input: mat[][] = { { 1, 1, 1 }, { 0, 1, 1 }, { 0, 0, 1 } }
Output: 6
Explanation: Flip row 1 to get:
{{1, 1, 1},
{1, 0, 0},
{0, 0, 1}}
And then flip column 1 to get:
{{1, 0, 1},
{1, 1, 0},
{0, 1, 1}}

Approach: The approach is based on the precomputation technique and traversal of the array. Follow the steps to solve the problem.

• Maintain a rows[] array which stores the amount of 1s obtained after flipping a respective row.
• Also, maintain a cols[] array which stores the amount of 1s obtained after flipping a respective column.
• Then count the total number of 1s in the entire matrix.
• Simply traverse on each row and column pair and maintain a maxi variable which is the global max amount of 1s obtained after flipping both row and column.
• Keep a note that if a column and row are both flipped, the square in which they overlap will still remain the same.
• To account for this, after calculation of the flips for row r and column c, if
• the value at mat[r] is 0, subtract two because then, there would be over-counting.
• but if the value at mat[r] is 1, simply add two because then, there would be under-counting.

Below is the implementation of the above approach :

## C++

 `// C++ code for the above approach:`   `#include ` `using` `namespace` `std;`   `// Function to find the maximum 1s` `int` `maximizeOnes(vector >& mat,` `                 ``int` `n, ``int` `m)` `{` `    ``// int n = arr.size();` `    ``// int m = arr.size();` `    ``vector<``int``> rows(n);` `    ``vector<``int``> cols(m);` `    ``int` `total = 0, maxi = INT_MIN, sum = 0;` `    ``for` `(``int` `i = 0; i < m; i++) {`   `        ``// Sum is a temporary tracker` `        ``// For each row and column` `        ``sum = 0;` `        ``for` `(``int` `j = 0; j < n; j++) {` `            ``sum += mat[j][i] == 0 ? 1 : -1;` `        ``}`   `        ``// Count of 1's after flip` `        ``// In each column` `        ``cols[i] = sum;` `    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``sum = 0;` `        ``for` `(``int` `j = 0; j < m; j++) {` `            ``sum += mat[i][j] == 0 ? 1 : -1;`   `            ``// Total number of 1s in matrix` `            ``total += mat[i][j];` `        ``}`   `        ``// Count of 1's after flip` `        ``// In each row` `        ``rows[i] = sum;` `    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = 0; j < m; j++) {`   `            ``// No. of 1's after` `            ``// Flipping row and column` `            ``int` `temp = cols[j] + rows[i];`   `            ``// Overlapping condition` `            ``// As mentioned above` `            ``temp` `                ``+= mat[i][j] == 1 ? 2 : -2;`   `            ``// Updating the global maxi value` `            ``maxi = max(maxi, temp);` `        ``}` `    ``}` `    ``return` `total + maxi;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 3;` `    ``int` `M = 3;` `    ``vector > mat` `        ``= { { 1, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 } };` `    ``cout << maximizeOnes(mat, N, M) << ``"\n"``;` `    ``return` `0;` `}`

## Java

 `// JAVA code for the above approach:` `import` `java.util.*;` `class` `GFG ` `{`   `  ``// Function to find the maximum 1s` `  ``public` `static` `int` `    ``maximizeOnes(ArrayList > mat, ``int` `n,` `                 ``int` `m)` `  ``{` `    `  `    ``// int n = arr.size();` `    ``// int m = arr.size();` `    ``int` `rows[] = ``new` `int``[n];` `    ``int` `cols[] = ``new` `int``[m];` `    ``int` `total = ``0``, maxi = Integer.MIN_VALUE, sum = ``0``;` `    ``for` `(``int` `i = ``0``; i < m; i++) {`   `      ``// Sum is a temporary tracker` `      ``// For each row and column` `      ``sum = ``0``;` `      ``for` `(``int` `j = ``0``; j < n; j++) {` `        ``sum += mat.get(j).get(i) == ``0` `? ``1` `: -``1``;` `      ``}`   `      ``// Count of 1's after flip` `      ``// In each column` `      ``cols[i] = sum;` `    ``}` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``sum = ``0``;` `      ``for` `(``int` `j = ``0``; j < m; j++) {` `        ``sum += mat.get(i).get(j) == ``0` `? ``1` `: -``1``;`   `        ``// Total number of 1s in matrix` `        ``total += mat.get(i).get(j);` `      ``}`   `      ``// Count of 1's after flip` `      ``// In each row` `      ``rows[i] = sum;` `    ``}` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``for` `(``int` `j = ``0``; j < m; j++) {`   `        ``// No. of 1's after` `        ``// Flipping row and column` `        ``int` `temp = cols[j] + rows[i];`   `        ``// Overlapping condition` `        ``// As mentioned above` `        ``temp += mat.get(i).get(j) == ``1` `? ``2` `: -``2``;`   `        ``// Updating the global maxi value` `        ``maxi = Math.max(maxi, temp);` `      ``}` `    ``}` `    ``return` `total + maxi;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `N = ``3``;` `    ``int` `M = ``3``;` `    ``ArrayList > mat` `      ``= ``new` `ArrayList >();` `    ``ArrayList temp1 = ``new` `ArrayList(` `      ``Arrays.asList(``1``, ``0``, ``1``));` `    ``ArrayList temp2 = ``new` `ArrayList(` `      ``Arrays.asList(``0``, ``1``, ``0``));` `    ``ArrayList temp3 = ``new` `ArrayList(` `      ``Arrays.asList(``1``, ``0``, ``0``));` `    ``mat.add(temp1);` `    ``mat.add(temp2);` `    ``mat.add(temp3);` `    ``System.out.println(maximizeOnes(mat, N, M));` `  ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# Python code for the above approach`   `# Function to find the maximum 1s` `import` `sys` `def` `maximizeOnes(mat,n, m):` `        `  `    ``# int n = arr.size();` `    ``# int m = arr.size();` `    ``rows ``=` `[``0``]``*``n` `    ``cols ``=` `[``0``]``*``m` `    ``total,maxi,``sum` `=` `0``,``-``sys.maxsize``-``1``,``0` `    ``for` `i ``in` `range``(m):`   `        ``# Sum is a temporary tracker` `        ``# For each row and column` `        ``sum` `=` `0` `        ``for` `j ``in` `range``(n):` `            ``sum` `+``=` `1` `if` `mat[j][i] ``=``=` `0` `else` `-``1`   `        ``# Count of 1's after flip` `        ``# In each column` `        ``cols[i] ``=` `sum`   `    ``for` `i ``in` `range``(n):` `        ``sum` `=` `0` `        ``for` `j ``in` `range``(m):`   `            ``sum` `+``=` `1` `if` `mat[i][j] ``=``=` `0` `else` `-``1`   `            ``# Total number of 1s in matrix` `            ``total ``+``=` `mat[i][j]`   `        ``# Count of 1's after flip` `        ``# In each row` `        ``rows[i] ``=` `sum`   `    ``for` `i ``in` `range``(n):` `        ``for` `j ``in` `range``(m):`   `            ``# No. of 1's after` `            ``# Flipping row and column` `            ``temp ``=` `cols[j] ``+` `rows[i]`   `            ``# Overlapping condition` `            ``# As mentioned above` `            ``temp ``+``=` `2` `if` `mat[i][j] ``=``=` `1` `else` `-``2`   `            ``# Updating the global maxi value` `            ``maxi ``=` `max``(maxi, temp)`   `    ``return` `total ``+` `maxi`   `# Driver code` `N ``=` `3` `M ``=` `3` `mat ``=` `[[``1``, ``0``, ``1``], [``0``, ``1``, ``0``], [``1``, ``0``, ``0``]]` `print``(maximizeOnes(mat, N, M))`   `# This code is contributed by shinjanpatra`

## C#

 `// C# code for the above approach:` `using` `System;` `class` `GFG {`   `  ``// Function to find the maximum 1s` `  ``static` `int` `maximizeOnes(``int``[, ] mat, ``int` `n, ``int` `m)` `  ``{`   `    ``// int n = arr.size();` `    ``// int m = arr.size();` `    ``int``[] rows = ``new` `int``[n];` `    ``int``[] cols = ``new` `int``[m];` `    ``int` `total = 0, maxi = Int32.MinValue, sum = 0;` `    ``for` `(``int` `i = 0; i < m; i++) {`   `      ``// Sum is a temporary tracker` `      ``// For each row and column` `      ``sum = 0;` `      ``for` `(``int` `j = 0; j < n; j++) {` `        ``sum += mat[j, i] == 0 ? 1 : -1;` `      ``}`   `      ``// Count of 1's after flip` `      ``// In each column` `      ``cols[i] = sum;` `    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``sum = 0;` `      ``for` `(``int` `j = 0; j < m; j++) {` `        ``sum += mat[i, j] == 0 ? 1 : -1;`   `        ``// Total number of 1s in matrix` `        ``total += mat[i, j];` `      ``}`   `      ``// Count of 1's after flip` `      ``// In each row` `      ``rows[i] = sum;` `    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``for` `(``int` `j = 0; j < m; j++) {`   `        ``// No. of 1's after` `        ``// Flipping row and column` `        ``int` `temp = cols[j] + rows[i];`   `        ``// Overlapping condition` `        ``// As mentioned above` `        ``temp += mat[i, j] == 1 ? 2 : -2;`   `        ``// Updating the global maxi value` `        ``maxi = Math.Max(maxi, temp);` `      ``}` `    ``}` `    ``return` `total + maxi;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int` `N = 3;` `    ``int` `M = 3;` `    ``int``[, ] mat` `      ``= { { 1, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 } };` `    ``Console.WriteLine(maximizeOnes(mat, N, M));` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`8`

Time Complexity: O(N * M)
Auxiliary Space: O(N + M)

My Personal Notes arrow_drop_up
Recommended Articles
Page :