# Maximum size square sub-matrix with all 1s

• Difficulty Level : Medium
• Last Updated : 12 May, 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] = M[i];``    ` `    ``/* Set first row of S[][]*/``    ``for``(j = 0; j < C; j++)``        ``S[j] = M[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; 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] = M[i];` `/* Set first row of S[][]*/`   `for``(j = 0; j < C; j++)``    ``S[j] = M[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; 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[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 entrie at the current position``            ``int` `Entrie = M[i][j];``            ``if``(Entrie)``                ``if``(j)``                    ``Entrie = 1 + min(S[j - 1], min(S[j - 1], S[j]));` `            ``// Save the last entrie and add the new one``            ``S[j] = S[j];``            ``S[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.`

## Javascript

 ``

## 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);``}``}`
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