Open in App
Not now

# Maximum size square sub-matrix with all 1s

• Difficulty Level : Medium
• Last Updated : 30 Nov, 2022

Given a binary matrix, find out the maximum size square sub-matrix with all 1s.
For example, consider the below binary matrix.

Algorithm:
Let the given binary matrix be M[R][C]. The idea of the algorithm is to construct an auxiliary size matrix S[][] in which each entry S[i][j] represents the size of the square sub-matrix with all 1s including M[i][j] where M[i][j] is the rightmost and bottom-most entry in sub-matrix.

```1) Construct a sum matrix S[R][C] for the given M[R][C].
a)    Copy first row and first columns as it is from M[][] to S[][]
b)    For other entries, use following expressions to construct S[][]
If M[i][j] is 1 then
S[i][j] = min(S[i][j-1], S[i-1][j], S[i-1][j-1]) + 1
Else /*If M[i][j] is 0*/
S[i][j] = 0
2) Find the maximum entry in S[R][C]
3) Using the value and coordinates of maximum entry in S[i], print
sub-matrix of M[][]```

For the given M[R][C] in the above example, constructed S[R][C] would be:

```   0  1  1  0  1
1  1  0  1  0
0  1  1  1  0
1  1  2  2  0
1  2  2  3  1
0  0  0  0  0```

The value of the maximum entry in the above matrix is 3 and the coordinates of the entry are (4, 3). Using the maximum value and its coordinates, we can find out the required sub-matrix.

## C++

 `// C++ code for Maximum size square` `// sub-matrix with all 1s` `#include ` `#define bool int` `#define R 6` `#define C 5` `using` `namespace` `std;`   `void` `printMaxSubSquare(``bool` `M[R][C])` `{` `    ``int` `i, j;` `    ``int` `S[R][C];` `    ``int` `max_of_s, max_i, max_j;`   `    ``/* Set first column of S[][]*/` `    ``for` `(i = 0; i < R; i++)` `        ``S[i][0] = M[i][0];`   `    ``/* Set first row of S[][]*/` `    ``for` `(j = 0; j < C; j++)` `        ``S[0][j] = M[0][j];`   `    ``/* Construct other entries of S[][]*/` `    ``for` `(i = 1; i < R; i++) {` `        ``for` `(j = 1; j < C; j++) {` `            ``if` `(M[i][j] == 1)` `                ``S[i][j]` `                    ``= min({ S[i][j - 1], S[i - 1][j],` `                            ``S[i - 1][j - 1] })` `                      ``+ 1; ``// better of using min in case of` `                           ``// arguments more than 2` `            ``else` `                ``S[i][j] = 0;` `        ``}` `    ``}`   `    ``/* Find the maximum entry, and indexes of maximum entry` `        ``in S[][] */` `    ``max_of_s = S[0][0];` `    ``max_i = 0;` `    ``max_j = 0;` `    ``for` `(i = 0; i < R; i++) {` `        ``for` `(j = 0; j < C; j++) {` `            ``if` `(max_of_s < S[i][j]) {` `                ``max_of_s = S[i][j];` `                ``max_i = i;` `                ``max_j = j;` `            ``}` `        ``}` `    ``}`   `    ``cout << ``"Maximum size sub-matrix is: \n"``;` `    ``for` `(i = max_i; i > max_i - max_of_s; i--) {` `        ``for` `(j = max_j; j > max_j - max_of_s; j--) {` `            ``cout << M[i][j] << ``" "``;` `        ``}` `        ``cout << ``"\n"``;` `    ``}` `}`   `/* Driver code */` `int` `main()` `{` `    ``bool` `M[R][C] = { { 0, 1, 1, 0, 1 }, { 1, 1, 0, 1, 0 },` `                     ``{ 0, 1, 1, 1, 0 }, { 1, 1, 1, 1, 0 },` `                     ``{ 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 } };`   `    ``printMaxSubSquare(M);` `}`   `// This code is contributed by rathbhupendra`

## C

 `// C code for Maximum size square` `// sub-matrix with all 1s` `#include ` `#define bool int` `#define R 6` `#define C 5`   `void` `printMaxSubSquare(``bool` `M[R][C])` `{` `    ``int` `i, j;` `    ``int` `S[R][C];` `    ``int` `max_of_s, max_i, max_j;`   `    ``/* Set first column of S[][]*/` `    ``for` `(i = 0; i < R; i++)` `        ``S[i][0] = M[i][0];`   `    ``/* Set first row of S[][]*/` `    ``for` `(j = 0; j < C; j++)` `        ``S[0][j] = M[0][j];`   `    ``/* Construct other entries of S[][]*/` `    ``for` `(i = 1; i < R; i++) {` `        ``for` `(j = 1; j < C; j++) {` `            ``if` `(M[i][j] == 1)` `                ``S[i][j] = min(S[i][j - 1], S[i - 1][j],` `                              ``S[i - 1][j - 1])` `                          ``+ 1;` `            ``else` `                ``S[i][j] = 0;` `        ``}` `    ``}`   `    ``/* Find the maximum entry, and indexes of maximum entry` `        ``in S[][] */` `    ``max_of_s = S[0][0];` `    ``max_i = 0;` `    ``max_j = 0;` `    ``for` `(i = 0; i < R; i++) {` `        ``for` `(j = 0; j < C; j++) {` `            ``if` `(max_of_s < S[i][j]) {` `                ``max_of_s = S[i][j];` `                ``max_i = i;` `                ``max_j = j;` `            ``}` `        ``}` `    ``}`   `    ``printf``(``"Maximum size sub-matrix is: \n"``);` `    ``for` `(i = max_i; i > max_i - max_of_s; i--) {` `        ``for` `(j = max_j; j > max_j - max_of_s; j--) {` `            ``printf``(``"%d "``, M[i][j]);` `        ``}` `        ``printf``(``"\n"``);` `    ``}` `}`   `/* UTILITY FUNCTIONS */` `/* Function to get minimum of three values */` `int` `min(``int` `a, ``int` `b, ``int` `c)` `{` `    ``int` `m = a;` `    ``if` `(m > b)` `        ``m = b;` `    ``if` `(m > c)` `        ``m = c;` `    ``return` `m;` `}`   `/* Driver function to test above functions */` `int` `main()` `{` `    ``bool` `M[R][C] = { { 0, 1, 1, 0, 1 }, { 1, 1, 0, 1, 0 },` `                     ``{ 0, 1, 1, 1, 0 }, { 1, 1, 1, 1, 0 },` `                     ``{ 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 } };`   `    ``printMaxSubSquare(M);` `    ``getchar``();` `}`

## Java

 `// JAVA Code for Maximum size square` `// sub-matrix with all 1s` `public` `class` `GFG {` `    ``// method for Maximum size square sub-matrix with all 1s` `    ``static` `void` `printMaxSubSquare(``int` `M[][])` `    ``{` `        ``int` `i, j;` `        ``int` `R = M.length; ``// no of rows in M[][]` `        ``int` `C = M[``0``].length; ``// no of columns in M[][]` `        ``int` `S[][] = ``new` `int``[R][C];`   `        ``int` `max_of_s, max_i, max_j;`   `        ``/* Set first column of S[][]*/` `        ``for` `(i = ``0``; i < R; i++)` `            ``S[i][``0``] = M[i][``0``];`   `        ``/* Set first row of S[][]*/` `        ``for` `(j = ``0``; j < C; j++)` `            ``S[``0``][j] = M[``0``][j];`   `        ``/* Construct other entries of S[][]*/` `        ``for` `(i = ``1``; i < R; i++) {` `            ``for` `(j = ``1``; j < C; j++) {` `                ``if` `(M[i][j] == ``1``)` `                    ``S[i][j] = Math.min(` `                                  ``S[i][j - ``1``],` `                                  ``Math.min(S[i - ``1``][j],` `                                           ``S[i - ``1``][j - ``1``]))` `                              ``+ ``1``;` `                ``else` `                    ``S[i][j] = ``0``;` `            ``}` `        ``}`   `        ``/* Find the maximum entry, and indexes of maximum` `           ``entry in S[][] */` `        ``max_of_s = S[``0``][``0``];` `        ``max_i = ``0``;` `        ``max_j = ``0``;` `        ``for` `(i = ``0``; i < R; i++) {` `            ``for` `(j = ``0``; j < C; j++) {` `                ``if` `(max_of_s < S[i][j]) {` `                    ``max_of_s = S[i][j];` `                    ``max_i = i;` `                    ``max_j = j;` `                ``}` `            ``}` `        ``}`   `        ``System.out.println(``"Maximum size sub-matrix is: "``);` `        ``for` `(i = max_i; i > max_i - max_of_s; i--) {` `            ``for` `(j = max_j; j > max_j - max_of_s; j--) {` `                ``System.out.print(M[i][j] + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `M[][]` `            ``= { { ``0``, ``1``, ``1``, ``0``, ``1` `}, { ``1``, ``1``, ``0``, ``1``, ``0` `},` `                ``{ ``0``, ``1``, ``1``, ``1``, ``0` `}, { ``1``, ``1``, ``1``, ``1``, ``0` `},` `                ``{ ``1``, ``1``, ``1``, ``1``, ``1` `}, { ``0``, ``0``, ``0``, ``0``, ``0` `} };`   `        ``printMaxSubSquare(M);` `    ``}` `}`

## Python3

 `# Python3 code for Maximum size` `# square sub-matrix with all 1s`   `def` `printMaxSubSquare(M):` `    ``R ``=` `len``(M)  ``# no. of rows in M[][]` `    ``C ``=` `len``(M[``0``])  ``# no. of columns in M[][]`   `    ``S ``=` `[]` `    ``for` `i ``in` `range``(R):` `        ``temp ``=` `[]` `        ``for` `j ``in` `range``(C):` `            ``if` `i ``=``=` `0` `or` `j ``=``=` `0``:` `                ``temp ``+``=` `M[i][j],` `            ``else``:` `                ``temp ``+``=` `0``,` `        ``S ``+``=` `temp,` `    ``# here we have set the first row and first column of S same as input matrix, other entries are set to 0`   `    ``# Update other entries` `    ``for` `i ``in` `range``(``1``, R):` `        ``for` `j ``in` `range``(``1``, C):` `            ``if` `(M[i][j] ``=``=` `1``):` `                ``S[i][j] ``=` `min``(S[i][j``-``1``], S[i``-``1``][j],` `                              ``S[i``-``1``][j``-``1``]) ``+` `1` `            ``else``:` `                ``S[i][j] ``=` `0`   `    ``# Find the maximum entry and` `    ``# indices of maximum entry in S[][]` `    ``max_of_s ``=` `S[``0``][``0``]` `    ``max_i ``=` `0` `    ``max_j ``=` `0` `    ``for` `i ``in` `range``(R):` `        ``for` `j ``in` `range``(C):` `            ``if` `(max_of_s < S[i][j]):` `                ``max_of_s ``=` `S[i][j]` `                ``max_i ``=` `i` `                ``max_j ``=` `j`   `    ``print``(``"Maximum size sub-matrix is: "``)` `    ``for` `i ``in` `range``(max_i, max_i ``-` `max_of_s, ``-``1``):` `        ``for` `j ``in` `range``(max_j, max_j ``-` `max_of_s, ``-``1``):` `            ``print``(M[i][j], end``=``" "``)` `        ``print``("")`     `# Driver Program` `M ``=` `[[``0``, ``1``, ``1``, ``0``, ``1``],` `     ``[``1``, ``1``, ``0``, ``1``, ``0``],` `     ``[``0``, ``1``, ``1``, ``1``, ``0``],` `     ``[``1``, ``1``, ``1``, ``1``, ``0``],` `     ``[``1``, ``1``, ``1``, ``1``, ``1``],` `     ``[``0``, ``0``, ``0``, ``0``, ``0``]]`   `printMaxSubSquare(M)`   `# This code is contributed by Soumen Ghosh`

## C#

 `// C# Code for Maximum size square` `// sub-matrix with all 1s`   `using` `System;`   `public` `class` `GFG {` `    ``// method for Maximum size square sub-matrix with all 1s` `    ``static` `void` `printMaxSubSquare(``int``[, ] M)` `    ``{` `        ``int` `i, j;` `        ``// no of rows in M[,]` `        ``int` `R = M.GetLength(0);` `        ``// no of columns in M[,]` `        ``int` `C = M.GetLength(1);` `        ``int``[, ] S = ``new` `int``[R, C];`   `        ``int` `max_of_s, max_i, max_j;`   `        ``/* Set first column of S[,]*/` `        ``for` `(i = 0; i < R; i++)` `            ``S[i, 0] = M[i, 0];`   `        ``/* Set first row of S[][]*/` `        ``for` `(j = 0; j < C; j++)` `            ``S[0, j] = M[0, j];`   `        ``/* Construct other entries of S[,]*/` `        ``for` `(i = 1; i < R; i++) {` `            ``for` `(j = 1; j < C; j++) {` `                ``if` `(M[i, j] == 1)` `                    ``S[i, j] = Math.Min(` `                                  ``S[i, j - 1],` `                                  ``Math.Min(S[i - 1, j],` `                                           ``S[i - 1, j - 1]))` `                              ``+ 1;` `                ``else` `                    ``S[i, j] = 0;` `            ``}` `        ``}`   `        ``/* Find the maximum entry, and indexes of` `            ``maximum entry in S[,] */` `        ``max_of_s = S[0, 0];` `        ``max_i = 0;` `        ``max_j = 0;` `        ``for` `(i = 0; i < R; i++) {` `            ``for` `(j = 0; j < C; j++) {` `                ``if` `(max_of_s < S[i, j]) {` `                    ``max_of_s = S[i, j];` `                    ``max_i = i;` `                    ``max_j = j;` `                ``}` `            ``}` `        ``}`   `        ``Console.WriteLine(``"Maximum size sub-matrix is: "``);` `        ``for` `(i = max_i; i > max_i - max_of_s; i--) {` `            ``for` `(j = max_j; j > max_j - max_of_s; j--) {` `                ``Console.Write(M[i, j] + ``" "``);` `            ``}` `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[, ] M = ``new` `int``[6, 5] {` `            ``{ 0, 1, 1, 0, 1 }, { 1, 1, 0, 1, 0 },` `            ``{ 0, 1, 1, 1, 0 }, { 1, 1, 1, 1, 0 },` `            ``{ 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 }` `        ``};`   `        ``printMaxSubSquare(M);` `    ``}` `}`

## PHP

 ` ``\$max_i` `- ``\$max_of_s``; ``\$i``--) ` `    ``{ ` `        ``for``(``\$j` `= ``\$max_j``; ` `            ``\$j` `> ``\$max_j` `- ``\$max_of_s``; ``\$j``--) ` `        ``{ ` `            ``echo` `\$M``[``\$i``][``\$j``], ``" "` `; ` `        ``} ` `        ``echo` `"\n"` `;` `    ``} ` `} `   `# Driver code` `\$M` `= ``array``(``array``(0, 1, 1, 0, 1), ` `           ``array``(1, 1, 0, 1, 0), ` `           ``array``(0, 1, 1, 1, 0), ` `           ``array``(1, 1, 1, 1, 0), ` `           ``array``(1, 1, 1, 1, 1), ` `           ``array``(0, 0, 0, 0, 0)); ` `    `  `\$R` `= 6 ;` `\$C` `= 5 ;         ` `printMaxSubSquare(``\$M``, ``\$R``, ``\$C``); `   `// This code is contributed by Ryuga` `?>`

## Javascript

 ``

Output

```Maximum size sub-matrix is:
1 1 1
1 1 1
1 1 1 ```

Time Complexity: O(m*n) where m is the number of rows and n is the number of columns in the given matrix.
Auxiliary Space: O(m*n) where m is the number of rows and n is the number of columns in the given matrix.

Space Optimized Solution: In order to compute an entry at any position in the matrix we only need the current row and the previous row.

## C++

 `// C++ code for Maximum size square` `// sub-matrix with all 1s` `// (space optimized solution)` `#include `   `using` `namespace` `std;`   `#define R 6` `#define C 5`   `void` `printMaxSubSquare(``bool` `M[R][C])` `{` `    ``int` `S[2][C], Max = 0;`   `    ``// set all elements of S to 0 first` `    ``memset``(S, 0, ``sizeof``(S));`   `    ``// Construct the entries` `    ``for` `(``int` `i = 0; i < R; i++)` `        ``for` `(``int` `j = 0; j < C; j++) {`   `            ``// Compute the entry at the current position` `            ``int` `Entrie = M[i][j];` `            ``if` `(Entrie)` `                ``if` `(j)` `                    ``Entrie` `                        ``= 1` `                          ``+ min(S[1][j - 1],` `                                ``min(S[0][j - 1], S[1][j]));`   `            ``// Save the last entry and add the new one` `            ``S[0][j] = S[1][j];` `            ``S[1][j] = Entrie;`   `            ``// Keep track of the max square length` `            ``Max = max(Max, Entrie);` `        ``}`   `    ``// Print the square` `    ``cout << ``"Maximum size sub-matrix is: \n"``;` `    ``for` `(``int` `i = 0; i < Max; i++, cout << ``'\n'``)` `        ``for` `(``int` `j = 0; j < Max; j++)` `            ``cout << ``"1 "``;` `}`   `// Driver code` `int` `main()` `{` `    ``bool` `M[R][C] = { { 0, 1, 1, 0, 1 }, { 1, 1, 0, 1, 0 },` `                     ``{ 0, 1, 1, 1, 0 }, { 1, 1, 1, 1, 0 },` `                     ``{ 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 } };`   `    ``printMaxSubSquare(M);`   `    ``return` `0;`   `    ``// This code is contributed` `    ``// by Gatea David` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG {`   `    ``static` `int` `R = ``6``;` `    ``static` `int` `C = ``5``;`   `    ``static` `void` `printMaxSubSquare(``int` `M[][])` `    ``{` `        ``int` `S[][] = ``new` `int``[``2``][C], Max = ``0``;`   `        ``// set all elements of S to 0 first` `        ``for` `(``int` `i = ``0``; i < ``2``; i++) {` `            ``for` `(``int` `j = ``0``; j < C; j++) {` `                ``S[i][j] = ``0``;` `            ``}` `        ``}`   `        ``// Construct the entries` `        ``for` `(``int` `i = ``0``; i < R; i++) {` `            ``for` `(``int` `j = ``0``; j < C; j++) {`   `                ``// Compute the entrie at the current` `                ``// position` `                ``int` `Entrie = M[i][j];` `                ``if` `(Entrie != ``0``) {` `                    ``if` `(j != ``0``) {` `                        ``Entrie = ``1` `                                 ``+ Math.min(` `                                     ``S[``1``][j - ``1``],` `                                     ``Math.min(S[``0``][j - ``1``],` `                                              ``S[``1``][j]));` `                    ``}` `                ``}`   `                ``// Save the last entrie and add the new one` `                ``S[``0``][j] = S[``1``][j];` `                ``S[``1``][j] = Entrie;`   `                ``// Keep track of the max square length` `                ``Max = Math.max(Max, Entrie);` `            ``}` `        ``}`   `        ``// Print the square` `        ``System.out.print(``"Maximum size sub-matrix is: \n"``);` `        ``for` `(``int` `i = ``0``; i < Max; i++) {` `            ``for` `(``int` `j = ``0``; j < Max; j++) {` `                ``System.out.print(``"1 "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `M[][]` `            ``= { { ``0``, ``1``, ``1``, ``0``, ``1` `}, { ``1``, ``1``, ``0``, ``1``, ``0` `},` `                ``{ ``0``, ``1``, ``1``, ``1``, ``0` `}, { ``1``, ``1``, ``1``, ``1``, ``0` `},` `                ``{ ``1``, ``1``, ``1``, ``1``, ``1` `}, { ``0``, ``0``, ``0``, ``0``, ``0` `} };`   `        ``printMaxSubSquare(M);` `    ``}` `}`   `// This code is contributed by code_hunt.`

## Python3

 `# Python code for Maximum size square` `# sub-matrix with all 1s` `# (space optimized solution)`   `R ``=` `6` `C ``=` `5`     `def` `printMaxSubSquare(M):`   `    ``global` `R, C` `    ``Max` `=` `0`   `    ``# set all elements of S to 0 first` `    ``S ``=` `[[``0` `for` `col ``in` `range``(C)]``for` `row ``in` `range``(``2``)]`   `    ``# Construct the entries` `    ``for` `i ``in` `range``(R):` `        ``for` `j ``in` `range``(C):`   `            ``# Compute the entrie at the current position` `            ``Entrie ``=` `M[i][j]` `            ``if``(Entrie):` `                ``if``(j):` `                    ``Entrie ``=` `1` `+` `min``(S[``1``][j ``-` `1``], ``min``(S[``0``][j ``-` `1``], S[``1``][j]))`   `            ``# Save the last entrie and add the new one` `            ``S[``0``][j] ``=` `S[``1``][j]` `            ``S[``1``][j] ``=` `Entrie`   `            ``# Keep track of the max square length` `            ``Max` `=` `max``(``Max``, Entrie)`   `    ``# Print the square` `    ``print``(``"Maximum size sub-matrix is: "``)` `    ``for` `i ``in` `range``(``Max``):` `        ``for` `j ``in` `range``(``Max``):` `            ``print``(``"1"``, end``=``" "``)` `        ``print``()`     `# Driver code` `M ``=` `[[``0``, ``1``, ``1``, ``0``, ``1``],` `     ``[``1``, ``1``, ``0``, ``1``, ``0``],` `     ``[``0``, ``1``, ``1``, ``1``, ``0``],` `     ``[``1``, ``1``, ``1``, ``1``, ``0``],` `     ``[``1``, ``1``, ``1``, ``1``, ``1``],` `     ``[``0``, ``0``, ``0``, ``0``, ``0``]]`   `printMaxSubSquare(M)`   `# This code is contributed by shinjanpatra`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Numerics;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `    ``static` `int` `R = 6;` `    ``static` `int` `C = 5;`   `    ``static` `void` `printMaxSubSquare(``int``[, ] M)` `    ``{` `        ``int``[, ] S = ``new` `int``[2, C];` `        ``int` `Maxx = 0;`   `        ``// set all elements of S to 0 first` `        ``for` `(``int` `i = 0; i < 2; i++) {` `            ``for` `(``int` `j = 0; j < C; j++) {` `                ``S[i, j] = 0;` `            ``}` `        ``}`   `        ``// Construct the entries` `        ``for` `(``int` `i = 0; i < R; i++) {` `            ``for` `(``int` `j = 0; j < C; j++) {`   `                ``// Compute the entrie at the current` `                ``// position` `                ``int` `Entrie = M[i, j];` `                ``if` `(Entrie != 0) {` `                    ``if` `(j != 0) {` `                        ``Entrie = 1` `                                 ``+ Math.Min(` `                                     ``S[1, j - 1],` `                                     ``Math.Min(S[0, j - 1],` `                                              ``S[1, j]));` `                    ``}` `                ``}`   `                ``// Save the last entrie and add the new one` `                ``S[0, j] = S[1, j];` `                ``S[1, j] = Entrie;`   `                ``// Keep track of the max square length` `                ``Maxx = Math.Max(Maxx, Entrie);` `            ``}` `        ``}`   `        ``// Print the square` `        ``Console.Write(``"Maximum size sub-matrix is: \n"``);` `        ``for` `(``int` `i = 0; i < Maxx; i++) {` `            ``for` `(``int` `j = 0; j < Maxx; j++) {` `                ``Console.Write(``"1 "``);` `            ``}` `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int``[, ] M` `            ``= { { 0, 1, 1, 0, 1 }, { 1, 1, 0, 1, 0 },` `                ``{ 0, 1, 1, 1, 0 }, { 1, 1, 1, 1, 0 },` `                ``{ 1, 1, 1, 1, 1 }, { 0, 0, 0, 0, 0 } };`   `        ``printMaxSubSquare(M);` `    ``}` `}`

## Javascript

 ``

Output

```Maximum size sub-matrix is:
1 1 1
1 1 1
1 1 1 ```

Time Complexity: O(m*n) where m is the number of rows and n is the number of columns in the given matrix.
Auxiliary space: O(n) where n is the number of columns in the given matrix.

Please write comments if you find any bug in the above code/algorithm, or find other ways to solve the same problem

My Personal Notes arrow_drop_up
Related Articles