# Check whether row or column swaps produce maximum size binary sub-matrix with all 1s

Given a binary matrix, the task is to find whether row swaps or column swaps give maximum size sub-matrix with all 1’s. In a row swap, we are allowed to swap any two rows. In a column swap we are allowed to swap any two columns. Output “Row Swap” or “Column Swap” and the maximum size.

Examples:

```Input : 1 1 1
1 0 1
Output : Column Swap
4
By swapping column 1 and column 2(0-based indexing),
index (0, 0) to (1, 1) makes the largest binary
sub-matrix.

Input : 0 0 0
1 1 0
1 1 0
0 0 0
1 1 0
Output : Row Swap
6

Input : 1 1 0
0 0 0
0 0 0
1 1 0
1 1 0
0 0 0
1 1 0
Output : Row Swap
8
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to find both row swap and column swap maximum size binary submatrix and compare.

To find the maximum sized binary sub-matrix with row swaps allowed, make a 2-D array, say dp[i][j]. Each value of dp[i][j] contains the number of consecutive 1s on right side of (i,j) in i-th row. Now, store each column in the 1-D temporary array one by one, say b[] and sort, and find maximum b[i] * (n – i), since b[i] is indicating the sub-matrix width and (n – i) is sub-matrix height.

Similarly, to find the maximum size binary sub-matrix with column swap allowed, find dp[i][j], where each value contains the number of consecutive 1 below the (i, j) in j-th column. Similarly, store each row in the 1-D temporary array one by one, say b[] and sort. Find maximum b[i] * (m – i), since b[i] is indicating the submatrix height and (n – i) is submatrix width.

Below is the implementation of this approach:

## C++

 `// C++ program to find maximum binary sub-matrix ` `// with row swaps and column swaps. ` `#include ` `#define R 5 ` `#define C 3 ` `using` `namespace` `std; ` ` `  `// Precompute the number of consecutive 1 below the ` `// (i, j) in j-th column and the number of consecutive 1s ` `// on right side of (i, j) in i-th row. ` `void` `precompute(``int` `mat[R][C], ``int` `ryt[][C + 2], ` `                               ``int` `dwn[R + 2][C + 2]) ` `{ ` `    ``// Travesing the 2d matrix from top-right. ` `    ``for` `(``int` `j=C-1; j>=0; j--) ` `    ``{ ` `        ``for` `(``int` `i=0; i= 0; i--) ` `    ``{ ` `        ``for` `(``int` `j = 0; j < C; ++j) ` `        ``{ ` `            ``// If (i,j) contain 0, do nothing ` `            ``if` `(mat[i][j] == 0) ` `                ``dwn[i][j] = 0; ` ` `  `            ``// Counting consecutive 1 down to (i,j). ` `            ``else` `                ``dwn[i][j] = dwn[i + 1][j] + 1; ` `        ``} ` `    ``} ` `} ` ` `  `// Return maximum size submatrix with row swap allowed. ` `int` `solveRowSwap(``int` `ryt[R + 2][C + 2]) ` `{ ` `    ``int` `b[R] = { 0 }, ans = 0; ` ` `  `    ``for` `(``int` `j=0; j cswap)? (cout << ``"Row Swap\n"` `<< rswap << endl): ` `                     ``(cout << ``"Column Swap\n"` `<< cswap << endl); ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``int` `mat[R][C] = {{ 0, 0, 0 }, ` `                     ``{ 1, 1, 0 }, ` `                     ``{ 1, 1, 0 }, ` `                     ``{ 0, 0, 0 }, ` `                     ``{ 1, 1, 0 }}; ` ` `  `    ``findMax1s(mat); ` `    ``return` `0; ` `} `

## Java

 `import` `java.util.Arrays; ` ` `  `// Java program to find maximum binary sub-matrix ` `// with row swaps and column swaps. ` `class` `GFG { ` ` `  `    ``static` `int` `R = ``5``; ` `    ``static` `int` `C = ``3``; ` ` `  `// Precompute the number of consecutive 1 below the ` `// (i, j) in j-th column and the number of consecutive 1s ` `// on right side of (i, j) in i-th row. ` `    ``static` `void` `precompute(``int` `mat[][], ``int` `ryt[][], ` `            ``int` `dwn[][]) { ` `        ``// Travesing the 2d matrix from top-right. ` `        ``for` `(``int` `j = C - ``1``; j >= ``0``; j--) { ` `            ``for` `(``int` `i = ``0``; i < R; ++i) { ` `                ``// If (i,j) contain 0, do nothing ` `                ``if` `(mat[i][j] == ``0``) { ` `                    ``ryt[i][j] = ``0``; ` `                ``} ``// Counting consecutive 1 on right side ` `                ``else` `{ ` `                    ``ryt[i][j] = ryt[i][j + ``1``] + ``1``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Travesing the 2d matrix from bottom-left. ` `        ``for` `(``int` `i = R - ``1``; i >= ``0``; i--) { ` `            ``for` `(``int` `j = ``0``; j < C; ++j) { ` `                ``// If (i,j) contain 0, do nothing ` `                ``if` `(mat[i][j] == ``0``) { ` `                    ``dwn[i][j] = ``0``; ` `                ``} ``// Counting consecutive 1 down to (i,j). ` `                ``else` `{ ` `                    ``dwn[i][j] = dwn[i + ``1``][j] + ``1``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `// Return maximum size submatrix with row swap allowed. ` `    ``static` `int` `solveRowSwap(``int` `ryt[][]) { ` `        ``int` `b[] = ``new` `int``[R], ans = ``0``; ` ` `  `        ``for` `(``int` `j = ``0``; j < C; j++) { ` `            ``// Copying the column ` `            ``for` `(``int` `i = ``0``; i < R; i++) { ` `                ``b[i] = ryt[i][j]; ` `            ``} ` ` `  `            ``// Sort the copied array ` `            ``Arrays.sort(b); ` ` `  `            ``// Find maximum submatrix size. ` `            ``for` `(``int` `i = ``0``; i < R; ++i) { ` `                ``ans = Math.max(ans, b[i] * (R - i)); ` `            ``} ` `        ``} ` ` `  `        ``return` `ans; ` `    ``} ` ` `  `// Return maximum size submatrix with column ` `// swap allowed. ` `    ``static` `int` `solveColumnSwap(``int` `dwn[][]) { ` `        ``int` `b[] = ``new` `int``[C], ans = ``0``; ` ` `  `        ``for` `(``int` `i = ``0``; i < R; ++i) { ` `            ``// Copying the row. ` `            ``for` `(``int` `j = ``0``; j < C; ++j) { ` `                ``b[j] = dwn[i][j]; ` `            ``} ` ` `  `            ``// Sort the copied array ` `            ``Arrays.sort(b); ` ` `  `            ``// Find maximum submatrix size. ` `            ``for` `(``int` `k = ``0``; k < C; ++k) { ` `                ``ans = Math.max(ans, b[k] * (C - k)); ` `            ``} ` `        ``} ` ` `  `        ``return` `ans; ` `    ``} ` ` `  `    ``static` `void` `findMax1s(``int` `mat[][]) { ` `        ``int` `ryt[][] = ``new` `int``[R + ``2``][C + ``2``], dwn[][] = ``new` `int``[R + ``2``][C + ``2``]; ` ` `  `        ``precompute(mat, ryt, dwn); ` ` `  `        ``// Solving for row swap and column swap ` `        ``int` `rswap = solveRowSwap(ryt); ` `        ``int` `cswap = solveColumnSwap(dwn); ` ` `  `        ``// Comparing both. ` `        ``if` `(rswap > cswap) { ` `            ``System.out.println(``"Row Swap\n"` `+ rswap); ` `        ``} ``else` `{ ` `            ``System.out.println(``"Column Swap\n"` `+ cswap); ` `        ``} ` `    ``} ` ` `  `// Driven Program  ` `    ``public` `static` `void` `main(String[] args) { ` `        ``int` `mat[][] = {{``0``, ``0``, ``0``}, ` `        ``{``1``, ``1``, ``0``}, ` `        ``{``1``, ``1``, ``0``}, ` `        ``{``0``, ``0``, ``0``}, ` `        ``{``1``, ``1``, ``0``}}; ` ` `  `        ``findMax1s(mat); ` `    ``} ` `} ` ` `  `/* This Java code is contributed by PrinciRaj1992*/`

## Python3

 `# Python3 program to find maximum binary ` `# sub-matrix with row swaps and column swaps. ` `R, C ``=` `5``, ``3` ` `  `# Precompute the number of consecutive 1  ` `# below the (i, j) in j-th column and the  ` `# number of consecutive 1s on right side  ` `# of (i, j) in i-th row. ` `def` `precompute(mat, ryt, dwn): ` ` `  `    ``# Travesing the 2d matrix from top-right. ` `    ``for` `j ``in` `range``(C ``-` `1``, ``-``1``, ``-``1``): ` `     `  `        ``for` `i ``in` `range``(``0``, R): ` `         `  `            ``# If (i,j) contain 0, do nothing ` `            ``if` `mat[i][j] ``=``=` `0``: ` `                ``ryt[i][j] ``=` `0` ` `  `            ``# Counting consecutive 1 on right side ` `            ``else``: ` `                ``ryt[i][j] ``=` `ryt[i][j ``+` `1``] ``+` `1` `         `  `    ``# Travesing the 2d matrix from bottom-left. ` `    ``for` `i ``in` `range``(R ``-` `1``, ``-``1``, ``-``1``): ` `     `  `        ``for` `j ``in` `range``(``0``, C): ` `         `  `            ``# If (i,j) contain 0, do nothing ` `            ``if` `mat[i][j] ``=``=` `0``: ` `                ``dwn[i][j] ``=` `0` ` `  `            ``# Counting consecutive 1 down to (i,j). ` `            ``else``: ` `                ``dwn[i][j] ``=` `dwn[i ``+` `1``][j] ``+` `1` ` `  `# Return maximum size submatrix  ` `# with row swap allowed. ` `def` `solveRowSwap(ryt): ` ` `  `    ``b ``=` `[``0``] ``*` `R ` `    ``ans ``=` `0` ` `  `    ``for` `j ``in` `range``(``0``, C): ` `     `  `        ``# Copying the column ` `        ``for` `i ``in` `range``(``0``, R): ` `            ``b[i] ``=` `ryt[i][j] ` ` `  `        ``# Sort the copied array ` `        ``b.sort() ` ` `  `        ``# Find maximum submatrix size. ` `        ``for` `i ``in` `range``(``0``, R): ` `            ``ans ``=` `max``(ans, b[i] ``*` `(R ``-` `i)) ` `     `  `    ``return` `ans ` ` `  `# Return maximum size submatrix ` `# with column swap allowed. ` `def` `solveColumnSwap(dwn): ` ` `  `    ``b ``=` `[``0``] ``*` `C ` `    ``ans ``=` `0` ` `  `    ``for` `i ``in` `range``(``0``, R): ` `     `  `        ``# Copying the row. ` `        ``for` `j ``in` `range``(``0``, C): ` `            ``b[j] ``=` `dwn[i][j] ` ` `  `        ``# Sort the copied array ` `        ``b.sort() ` ` `  `        ``# Find maximum submatrix size. ` `        ``for` `i ``in` `range``(``0``, C): ` `            ``ans ``=` `max``(ans, b[i] ``*` `(C ``-` `i)) ` `     `  `    ``return` `ans ` ` `  `def` `findMax1s(mat): ` ` `  `    ``ryt ``=` `[[``0` `for` `i ``in` `range``(C ``+` `2``)]  ` `              ``for` `j ``in` `range``(R ``+` `2``)] ` `    ``dwn ``=` `[[``0` `for` `i ``in` `range``(C ``+` `2``)]  ` `              ``for` `j ``in` `range``(R ``+` `2``)] ` `     `  `    ``precompute(mat, ryt, dwn) ` ` `  `    ``# Solving for row swap and column swap ` `    ``rswap ``=` `solveRowSwap(ryt) ` `    ``cswap ``=` `solveColumnSwap(dwn) ` ` `  `    ``# Comparing both. ` `    ``if` `rswap > cswap: ``print``(``"Row Swap\n"``, rswap) ` `    ``else``: ``print``(``"Column Swap\n"``, cswap) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``mat ``=` `[[``0``, ``0``, ``0``], ` `           ``[``1``, ``1``, ``0``], ` `           ``[``1``, ``1``, ``0``], ` `           ``[``0``, ``0``, ``0``], ` `           ``[``1``, ``1``, ``0``]]  ` ` `  `    ``findMax1s(mat) ` `     `  `# This code is contributed by Rituraj Jain `

## C#

 `  `  `// C# program to find maximum binary sub-matrix ` `// with row swaps and column swaps. ` `using` `System; ` `public` `class` `GFG { ` `  `  `    ``static` `int` `R = 5; ` `    ``static` `int` `C = 3; ` `  `  `// Precompute the number of consecutive 1 below the ` `// (i, j) in j-th column and the number of consecutive 1s ` `// on right side of (i, j) in i-th row. ` `    ``static` `void` `precompute(``int` `[,]mat, ``int` `[,]ryt, ` `            ``int` `[,]dwn) { ` `        ``// Travesing the 2d matrix from top-right. ` `        ``for` `(``int` `j = C - 1; j >= 0; j--) { ` `            ``for` `(``int` `i = 0; i < R; ++i) { ` `                ``// If (i,j) contain 0, do nothing ` `                ``if` `(mat[i,j] == 0) { ` `                    ``ryt[i,j] = 0; ` `                ``} ``// Counting consecutive 1 on right side ` `                ``else` `{ ` `                    ``ryt[i,j] = ryt[i,j + 1] + 1; ` `                ``} ` `            ``} ` `        ``} ` `  `  `        ``// Travesing the 2d matrix from bottom-left. ` `        ``for` `(``int` `i = R - 1; i >= 0; i--) { ` `            ``for` `(``int` `j = 0; j < C; ++j) { ` `                ``// If (i,j) contain 0, do nothing ` `                ``if` `(mat[i,j] == 0) { ` `                    ``dwn[i,j] = 0; ` `                ``} ``// Counting consecutive 1 down to (i,j). ` `                ``else` `{ ` `                    ``dwn[i,j] = dwn[i + 1,j] + 1; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `  `  `// Return maximum size submatrix with row swap allowed. ` `    ``static` `int` `solveRowSwap(``int` `[,]ryt) { ` `        ``int` `[]b = ``new` `int``[R]; ``int` `ans = 0; ` `  `  `        ``for` `(``int` `j = 0; j < C; j++) { ` `            ``// Copying the column ` `            ``for` `(``int` `i = 0; i < R; i++) { ` `                ``b[i] = ryt[i,j]; ` `            ``} ` `  `  `            ``// Sort the copied array ` `            ``Array.Sort(b); ` `  `  `            ``// Find maximum submatrix size. ` `            ``for` `(``int` `i = 0; i < R; ++i) { ` `                ``ans = Math.Max(ans, b[i] * (R - i)); ` `            ``} ` `        ``} ` `  `  `        ``return` `ans; ` `    ``} ` `  `  `// Return maximum size submatrix with column ` `// swap allowed. ` `    ``static` `int` `solveColumnSwap(``int` `[,]dwn) { ` `        ``int` `[]b = ``new` `int``[C];``int` `ans = 0; ` `  `  `        ``for` `(``int` `i = 0; i < R; ++i) { ` `            ``// Copying the row. ` `            ``for` `(``int` `j = 0; j < C; ++j) { ` `                ``b[j] = dwn[i,j]; ` `            ``} ` `  `  `            ``// Sort the copied array ` `            ``Array.Sort(b); ` `  `  `            ``// Find maximum submatrix size. ` `            ``for` `(``int` `k = 0; k < C; ++k) { ` `                ``ans = Math.Max(ans, b[k] * (C - k)); ` `            ``} ` `        ``} ` `  `  `        ``return` `ans; ` `    ``} ` `  `  `    ``static` `void` `findMax1s(``int` `[,]mat) { ` `        ``int` `[,]ryt = ``new` `int``[R + 2,C + 2]; ` `        ``int` `[,]dwn = ``new` `int``[R + 2,C + 2]; ` `  `  `        ``precompute(mat, ryt, dwn); ` `  `  `        ``// Solving for row swap and column swap ` `        ``int` `rswap = solveRowSwap(ryt); ` `        ``int` `cswap = solveColumnSwap(dwn); ` `  `  `        ``// Comparing both. ` `        ``if` `(rswap > cswap) { ` `            ``Console.WriteLine(``"Row Swap\n"` `+ rswap); ` `        ``} ``else` `{ ` `            ``Console.WriteLine(``"Column Swap\n"` `+ cswap); ` `        ``} ` `    ``} ` `  `  `// Driven Program  ` `    ``public` `static` `void` `Main() { ` `        ``int` `[,]mat = {{0, 0, 0}, ` `        ``{1, 1, 0}, ` `        ``{1, 1, 0}, ` `        ``{0, 0, 0}, ` `        ``{1, 1, 0}}; ` `  `  `        ``findMax1s(mat); ` `    ``} ` `} ` `  `  `/* This C# code is contributed by PrinciRaj1992*/`

Output:

```Row Swap
6
```

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.