# Maximum size square sub-matrix with all 1s

• Difficulty Level : Medium
• Last Updated : 25 Jun, 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