# Largest Square in a Binary Matrix with at most K 1s for multiple Queries

• Difficulty Level : Hard
• Last Updated : 26 Aug, 2021

Given a binary matrix M where each element of the matrix will be 0 or 1, the task is to find the largest square that can be formed with center (i, j) and contains atmost K 1’s.

Input: M[][] = {
{1, 0, 1, 0, 0}
{1, 0, 1, 1, 1}
{1, 1, 1, 1, 1}
{1, 0, 0, 1, 0}},
i = 1, j = 2, K = 9
Output:
Explanation:
Maximum length square with center at (1, 2)
that can be formed is of 3 length from (0, 1) to (2, 4)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: M[][] = {
{ 1, 1, 1 },
{ 1, 1, 1 },
{ 1, 1, 1 }},
i = 1, j = 1, K = 9
Output: 3

Naive Approach:
For each query, consider all squares with center (i, j) and keep incrementing the length of the squares from 1 to its maximum possible value up to which the count of 1s in the square is less than K. The maximum possible value of the length of the square will be 2*MIN_DIST + 1 where MIN_DIST is the minimum distance of the center from the edges of the matrix. So for an R*C matrix with center (i, j),

`MIN_DIST = min( i, j, R-i-1, C-j-1 ) `

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the ``// largest square in the matrix such``// that it contains atmost K 1's`` ` `#include ``using` `namespace` `std;``const` `int` `MAX = 100;`` ` `// Function to calculate the``// largest square with atmost K``// 1s for Q queries``void` `largestSquare(``int` `matrix[][MAX],``             ``int` `R, ``int` `C, ``int` `q_i[],``            ``int` `q_j[], ``int` `K, ``int` `Q){``                 ` `    ``// Loop to solve for each query``    ``for` `(``int` `q = 0; q < Q; q++) {``        ``int` `i = q_i[q];``        ``int` `j = q_j[q];``        ``int` `min_dist = min(min(i, j),``          ``min(R - i - 1, C - j - 1));``        ``int` `ans = -1;``        ``for` `(``int` `k = 0; k <= min_dist;``                                 ``k++) {``            ``int` `count = 0;``            ``// Traversing the each sub``            ``// square and counting total``            ``for` `(``int` `row = i - k; ``              ``row <= i + k; row++)``                ``for` `(``int` `col = j - k;``                  ``col <= j + k; col++)``                    ``count += matrix[row][col];``             ` `            ``// Breaks when exceeds``            ``// the maximum count``            ``if` `(count > K)``                ``break``;``             ` `            ``ans = 2 * k + 1;``        ``}``        ``cout << ans << ``"\n"``;``    ``}``}`` ` `// Driver Code``int` `main()``{``    ``int` `matrix[][MAX] = { { 1, 0, 1, 0, 0 },``                        ``{ 1, 0, 1, 1, 1 },``                        ``{ 1, 1, 1, 1, 1 },``                        ``{ 1, 0, 0, 1, 0 } };``    ``int` `K = 9, Q = 1;``    ``int` `q_i[] = { 1 };``    ``int` `q_j[] = { 2 };``    ``largestSquare(matrix, 4, 5, q_i,``                          ``q_j, K, Q);``    ``return` `0;``}`

## Java

 `// Java implementation to find the ``// largest square in the matrix such``// that it contains atmost K 1's``class` `GFG{``     ` `static` `int` `MAX = ``100``;`` ` `// Function to calculate the``// largest square with atmost K``// 1s for Q queries``static` `void` `largestSquare(``int` `matrix[][], ``                          ``int` `R, ``int` `C, ``                          ``int` `q_i[], ``int` `q_j[], ``                          ``int` `K, ``int` `Q)``{``     ` `    ``// Loop to solve for each query``    ``for``(``int` `q = ``0``; q < Q; q++) ``    ``{``       ``int` `i = q_i[q];``       ``int` `j = q_j[q];``       ``int` `min_dist = Math.min(Math.min(i, j),``                      ``Math.min(R - i - ``1``, ``                               ``C - j - ``1``));``       ``int` `ans = -``1``;``       ``for``(``int` `k = ``0``; k <= min_dist; k++)``       ``{``          ``int` `count = ``0``;``           ` `          ``// Traversing the each sub``          ``// square and counting total``          ``for``(``int` `row = i - k; row <= i + k; row++)``             ``for``(``int` `col = j - k; col <= j + k; col++)``                ``count += matrix[row][col];``             ` `            ``// Breaks when exceeds``            ``// the maximum count``            ``if` `(count > K)``                ``break``;``             ` `            ``ans = ``2` `* k + ``1``;``        ``}``         ` `        ``System.out.print(ans + ``"\n"``);``    ``}``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `matrix[][] = { { ``1``, ``0``, ``1``, ``0``, ``0` `},``                       ``{ ``1``, ``0``, ``1``, ``1``, ``1` `},``                       ``{ ``1``, ``1``, ``1``, ``1``, ``1` `},``                       ``{ ``1``, ``0``, ``0``, ``1``, ``0` `} };``    ``int` `K = ``9``, Q = ``1``;``    ``int` `q_i[] = { ``1` `};``    ``int` `q_j[] = { ``2` `};``    ``largestSquare(matrix, ``4``, ``5``, q_i, q_j, K, Q);``}``}`` ` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 implementation to find the ``# largest square in the matrix such ``# that it contains at most K 1's `` ` `MAX` `=` `100`` ` `# Function to calculate the ``# largest square with atmost K ``# 1s for Q queries ``def` `largestSquare(matrix, R, C, q_i, q_j, K, Q): ``                 ` `    ``# Loop to solve for each query ``    ``for` `q ``in` `range``(Q): ``        ``i ``=` `q_i[q] ``        ``j ``=` `q_j[q] ``        ``min_dist ``=` `min``(``min``(i, j), ``                   ``min``(R ``-` `i ``-` `1``, C ``-` `j ``-` `1``)) ``        ``ans ``=` `-``1``        ``for` `k ``in` `range``(min_dist ``+` `1``):``             ` `            ``count ``=` `0``             ` `            ``# Traversing the each sub ``            ``# square and counting total ``            ``for` `row ``in` `range``(i ``-` `k, i ``+` `k ``+` `1``): ``                ``for` `col ``in` `range``(j ``-` `k, j ``+` `k ``+` `1``): ``                    ``count ``+``=` `matrix[row][col] ``             ` `            ``# Breaks when exceeds ``            ``# the maximum count ``            ``if` `count > K: ``                ``break``             ` `            ``ans ``=` `2` `*` `k ``+` `1``        ``print``(ans) ``         ` `# Driver Code ``matrix ``=` `[ [ ``1``, ``0``, ``1``, ``0``, ``0` `], ``           ``[ ``1``, ``0``, ``1``, ``1``, ``1` `], ``           ``[ ``1``, ``1``, ``1``, ``1``, ``1` `], ``           ``[ ``1``, ``0``, ``0``, ``1``, ``0` `] ] ``K ``=` `9``Q ``=` `1``q_i ``=` `[ ``1` `] ``q_j ``=` `[ ``2` `] ``largestSquare(matrix, ``4``, ``5``, q_i, q_j, K, Q)``                         ` `# This code is contributed by divyamohan123                     ``                    `

## C#

 `// C# implementation to find the ``// largest square in the matrix such``// that it contains atmost K 1's``using` `System;`` ` `class` `GFG{``     ` `//static int MAX = 100;`` ` `// Function to calculate the``// largest square with atmost K``// 1s for Q queries``static` `void` `largestSquare(``int` `[,]matrix, ``                          ``int` `R, ``int` `C, ``                          ``int` `[]q_i, ``int` `[]q_j, ``                          ``int` `K, ``int` `Q)``{``     ` `    ``// Loop to solve for each query``    ``for``(``int` `q = 0; q < Q; q++) ``    ``{``       ``int` `i = q_i[q];``       ``int` `j = q_j[q];``       ``int` `min_dist = Math.Min(Math.Min(i, j), ``                               ``Math.Min(R - i - 1,``                                        ``C - j - 1));``       ``int` `ans = -1;``       ``for``(``int` `k = 0; k <= min_dist; k++)``       ``{``          ``int` `count = 0;``           ` `          ``// Traversing the each sub``          ``// square and counting total``          ``for``(``int` `row = i - k; row <= i + k; row++)``             ``for``(``int` `col = j - k; col <= j + k; col++)``                ``count += matrix[row, col];``                 ` `          ``// Breaks when exceeds``          ``// the maximum count``          ``if` `(count > K)``              ``break``;``           ` `          ``ans = 2 * k + 1;``       ``}``       ``Console.Write(ans + ``"\n"``);``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[,]matrix = { { 1, 0, 1, 0, 0 },``                      ``{ 1, 0, 1, 1, 1 },``                      ``{ 1, 1, 1, 1, 1 },``                      ``{ 1, 0, 0, 1, 0 } };``    ``int` `K = 9, Q = 1;``    ``int` `[]q_i = {1};``    ``int` `[]q_j = {2};``     ` `    ``largestSquare(matrix, 4, 5, q_i, q_j, K, Q);``}``}`` ` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output :

`3`

The worst-case time complexity for the given solution is O(Q*N*N*MIN_DIST) where N is the length of the square(which is maximum 2*MIN_DIST + 1).

Efficient Approach using Dynamic Programming:
The idea is to use Dynamic Programming to count the number of 1s in each square and then increment the length by 1 until the limit and then finally check the count of the 1s is less than the K or not. If yes, then update the answer.
To compute the number of 1s in a submatrix from (x1, y1) to (x2, y2) using:

```Number of 1's = sumDP[x2][y2] - sumDP[x2][y1-1] -
sumDP[x1-1][y2] + sumDP[x1-1][y1-1]```

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the ``// largest square in the matrix such``// that it contains atmost K 1's`` ` `#include ``using` `namespace` `std;``const` `int` `MAX = 100;`` ` `// Function to find the ``// largest square in the matrix such``// that it contains atmost K 1's``void` `largestSquare(``int` `matrix[][MAX],``            ``int` `R, ``int` `C, ``int` `q_i[],``            ``int` `q_j[], ``int` `K, ``int` `Q){``     ` `    ``int` `countDP[R][C];``    ``memset``(countDP, 0, ``sizeof``(countDP));`` ` `    ``// Precomputing the countDP ``    ``// prefix sum of the matrix``    ``countDP[0][0] = matrix[0][0];``    ``for` `(``int` `i = 1; i < R; i++)``        ``countDP[i][0] = countDP[i - 1][0] + ``                             ``matrix[i][0];``    ``for` `(``int` `j = 1; j < C; j++)``        ``countDP[0][j] = countDP[0][j - 1] +``                             ``matrix[0][j];``    ``for` `(``int` `i = 1; i < R; i++)``        ``for` `(``int` `j = 1; j < C; j++)``            ``countDP[i][j] = matrix[i][j] +``                       ``countDP[i - 1][j] +``                       ``countDP[i][j - 1] -``                       ``countDP[i - 1][j - 1];``     ` `    ``// Loop to solve Queries``    ``for` `(``int` `q = 0; q < Q; q++) {``        ``int` `i = q_i[q];``        ``int` `j = q_j[q];``        ``// Calculating the maximum``        ``// possible distance of the``        ``// centre from edge``        ``int` `min_dist = min(min(i, j), ``          ``min(R - i - 1, C - j - 1));``        ``int` `ans = -1;``        ``for` `(``int` `k = 0; k <= min_dist;``                                  ``k++) {``            ``int` `x1 = i - k, x2 = i + k;``            ``int` `y1 = j - k, y2 = j + k;``             ` `            ``// Calculating the number``            ``// of 1s in the submatrix``            ``int` `count = countDP[x2][y2];``            ``if` `(x1 > 0)``                ``count -= countDP[x1 - 1][y2];``            ``if` `(y1 > 0)``                ``count -= countDP[x2][y1 - 1];``            ``if` `(x1 > 0 && y1 > 0)``                ``count += countDP[x1 - 1][y1 - 1];`` ` `            ``if` `(count > K)``                ``break``;``            ``ans = 2 * k + 1;``        ``}``        ``cout << ans << ``"\n"``;``    ``}``}`` ` `// Driver Code``int` `main()``{``    ``int` `matrix[][MAX] = { { 1, 0, 1, 0, 0 },``                        ``{ 1, 0, 1, 1, 1 },``                        ``{ 1, 1, 1, 1, 1 },``                        ``{ 1, 0, 0, 1, 0 } };`` ` `    ``int` `K = 9, Q = 1;``    ``int` `q_i[] = { 1 };``    ``int` `q_j[] = { 2 };``    ``largestSquare(matrix, 4, 5, q_i,``                          ``q_j, K, Q);``    ``return` `0;``}`

## Java

 `// Java implementation to find the ``// largest square in the matrix such``// that it contains atmost K 1's``import` `java.util.*;`` ` `class` `GFG{``     ` `static` `int` `MAX = ``100``;`` ` `// Function to find the ``// largest square in the matrix such``// that it contains atmost K 1's``static` `void` `largestSquare(``int` `matrix[][], ``int` `R,``                          ``int` `C, ``int` `q_i[], ``                          ``int` `q_j[], ``int` `K,``                          ``int` `Q)``{``    ``int` `[][]countDP = ``new` `int``[R][C];`` ` `    ``// Precomputing the countDP ``    ``// prefix sum of the matrix``    ``countDP[``0``][``0``] = matrix[``0``][``0``];``    ``for``(``int` `i = ``1``; i < R; i++)``        ``countDP[i][``0``] = countDP[i - ``1``][``0``] + ``                             ``matrix[i][``0``];``    ``for``(``int` `j = ``1``; j < C; j++)``        ``countDP[``0``][j] = countDP[``0``][j - ``1``] +``                         ``matrix[``0``][j];``    ``for``(``int` `i = ``1``; i < R; i++)``        ``for``(``int` `j = ``1``; j < C; j++)``            ``countDP[i][j] = matrix[i][j] +``                           ``countDP[i - ``1``][j] +``                           ``countDP[i][j - ``1``] -``                           ``countDP[i - ``1``][j - ``1``];``     ` `    ``// Loop to solve Queries``    ``for``(``int` `q = ``0``; q < Q; q++)``    ``{``        ``int` `i = q_i[q];``        ``int` `j = q_j[q];``         ` `        ``// Calculating the maximum``        ``// possible distance of the``        ``// centre from edge``        ``int` `min_dist = Math.min(Math.min(i, j), ``                       ``Math.min(R - i - ``1``, ``                                ``C - j - ``1``));``                                 ` `        ``int` `ans = -``1``;``        ``for``(``int` `k = ``0``; k <= min_dist; k++)``        ``{``            ``int` `x1 = i - k, x2 = i + k;``            ``int` `y1 = j - k, y2 = j + k;``             ` `            ``// Calculating the number``            ``// of 1s in the submatrix``            ``int` `count = countDP[x2][y2];``            ``if` `(x1 > ``0``)``                ``count -= countDP[x1 - ``1``][y2];``            ``if` `(y1 > ``0``)``                ``count -= countDP[x2][y1 - ``1``];``            ``if` `(x1 > ``0` `&& y1 > ``0``)``                ``count += countDP[x1 - ``1``][y1 - ``1``];``            ``if` `(count > K)``                ``break``;``            ``ans = ``2` `* k + ``1``;``        ``}``        ``System.out.print(ans + ``"\n"``);``    ``}``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `matrix[][] = { { ``1``, ``0``, ``1``, ``0``, ``0` `},``                       ``{ ``1``, ``0``, ``1``, ``1``, ``1` `},``                       ``{ ``1``, ``1``, ``1``, ``1``, ``1` `},``                       ``{ ``1``, ``0``, ``0``, ``1``, ``0` `} };`` ` `    ``int` `K = ``9``, Q = ``1``;``    ``int` `q_i[] = { ``1` `};``    ``int` `q_j[] = { ``2` `};``     ` `    ``largestSquare(matrix, ``4``, ``5``, q_i,``                        ``q_j, K, Q);``}``}`` ` `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 implementation to find the ``# largest square in the matrix such ``# that it contains atmost K 1's `` ` `# Function to find the largest ``# square in the matrix such ``# that it contains atmost K 1's ``def` `largestSquare(matrix, R, C, q_i, ``                     ``q_j, K, Q):``     ` `    ``countDP ``=` `[[``0` `for` `x ``in` `range``(C)]``                  ``for` `x ``in` `range``(R)] ``     ` `    ``# Precomputing the countDP ``    ``# prefix sum of the matrix ``    ``countDP[``0``][``0``] ``=` `matrix[``0``][``0``] ``     ` `    ``for` `i ``in` `range``(``1``, R):``        ``countDP[i][``0``] ``=` `(countDP[i ``-` `1``][``0``] ``+` `                          ``matrix[i][``0``])``     ` `    ``for` `j ``in` `range``(``1``, C):``        ``countDP[``0``][j] ``=` `(countDP[``0``][j ``-` `1``] ``+` `                          ``matrix[``0``][j])``     ` `    ``for` `i ``in` `range``(``1``, R):``        ``for` `j ``in` `range``(``1``, C):``            ``countDP[i][j] ``=` `(matrix[i][j] ``+` `                            ``countDP[i ``-` `1``][j] ``+` `                            ``countDP[i][j ``-` `1``] ``-` `                            ``countDP[i ``-` `1``][j ``-` `1``])``     ` `    ``# Loop to solve Queries ``    ``for` `q ``in` `range``(``0``, Q):``        ``i ``=` `q_i[q]``        ``j ``=` `q_j[q]``         ` `        ``# Calculating the maximum ``        ``# possible distance of the ``        ``# centre from edge ``        ``min_dist ``=` `min``(i, j, R ``-` `i ``-` `1``,``                             ``C ``-` `j ``-` `1``)``        ``ans ``=` `-``1``        ``for` `k ``in` `range``(``0``, min_dist ``+` `1``): ``            ``x1 ``=` `i ``-` `k``            ``x2 ``=` `i ``+` `k``            ``y1 ``=` `j ``-` `k``            ``y2 ``=` `j ``+` `k ``                 ` `            ``# Calculating the number ``            ``# of 1s in the submatrix ``            ``count ``=` `countDP[x2][y2]; ``             ` `            ``if` `(x1 > ``0``): ``                    ``count ``-``=` `countDP[x1 ``-` `1``][y2]``            ``if` `(y1 > ``0``):``                    ``count ``-``=` `countDP[x2][y1 ``-` `1``]``            ``if` `(x1 > ``0` `and` `y1 > ``0``):``                    ``count ``+``=` `countDP[x1 ``-` `1``][y1 ``-` `1``]``                 ` `            ``if` `(count > K):``                    ``break``                     ` `            ``ans ``=` `2` `*` `k ``+` `1``             ` `        ``print``(ans)``         ` `# Driver Code ``matrix ``=` `[ [ ``1``, ``0``, ``1``, ``0``, ``0` `], ``           ``[ ``1``, ``0``, ``1``, ``1``, ``1` `], ``           ``[ ``1``, ``1``, ``1``, ``1``, ``1` `], ``           ``[ ``1``, ``0``, ``0``, ``1``, ``0` `] ] ``K ``=` `9``Q ``=` `1``q_i ``=` `[``1``] ``q_j ``=` `[``2``] `` ` `largestSquare(matrix, ``4``, ``5``, q_i, q_j, K, Q) `` ` `# This code is contributed by Stream_Cipher`

## C#

 `// C# implementation to find the ``// largest square in the matrix such ``// that it contains atmost K 1's ``using` `System;`` ` `class` `GFG{ ``     ` `//static int MAX = 100; `` ` `// Function to find the ``// largest square in the matrix such ``// that it contains atmost K 1's ``static` `void` `largestSquare(``int` `[,]matrix, ``int` `R, ``                          ``int` `C, ``int` `[]q_i, ``                          ``int` `[]q_j, ``int` `K, ``                          ``int` `Q) ``{ ``    ``int` `[,]countDP = ``new` `int``[R, C]; `` ` `    ``// Precomputing the countDP ``    ``// prefix sum of the matrix ``    ``countDP[0, 0] = matrix[0, 0]; ``    ``for``(``int` `i = 1; i < R; i++) ``        ``countDP[i, 0] = countDP[i - 1, 0] + ``                             ``matrix[i, 0];``                              ` `    ``for``(``int` `j = 1; j < C; j++) ``        ``countDP[0, j] = countDP[0, j - 1] + ``                         ``matrix[0, j]; ``                          ` `    ``for``(``int` `i = 1; i < R; i++) ``        ``for``(``int` `j = 1; j < C; j++) ``            ``countDP[i, j] = matrix[i, j] + ``                           ``countDP[i - 1, j] + ``                           ``countDP[i, j - 1] - ``                           ``countDP[i - 1, j - 1]; ``     ` `    ``// Loop to solve Queries ``    ``for``(``int` `q = 0; q < Q; q++) ``    ``{ ``        ``int` `i = q_i[q]; ``        ``int` `j = q_j[q]; ``         ` `        ``// Calculating the maximum ``        ``// possible distance of the ``        ``// centre from edge ``        ``int` `min_dist = Math.Min(Math.Min(i, j), ``                       ``Math.Min(R - i - 1, ``                                ``C - j - 1)); ``                                 ` `        ``int` `ans = -1; ``        ``for``(``int` `k = 0; k <= min_dist; k++) ``        ``{ ``            ``int` `x1 = i - k, x2 = i + k; ``            ``int` `y1 = j - k, y2 = j + k; ``             ` `            ``// Calculating the number ``            ``// of 1s in the submatrix ``            ``int` `count = countDP[x2, y2]; ``            ``if` `(x1 > 0) ``                ``count -= countDP[x1 - 1, y2]; ``            ``if` `(y1 > 0) ``                ``count -= countDP[x2, y1 - 1]; ``            ``if` `(x1 > 0 && y1 > 0) ``                ``count += countDP[x1 - 1, y1 - 1]; ``            ``if` `(count > K) ``                ``break``; `` ` `            ``ans = 2 * k + 1; ``        ``} ``        ``Console.Write(ans + ``"\n"``); ``    ``} ``} `` ` `// Driver Code ``public` `static` `void` `Main(String[] args) ``{ ``    ``int` `[,]matrix = { { 1, 0, 1, 0, 0 }, ``                      ``{ 1, 0, 1, 1, 1 }, ``                      ``{ 1, 1, 1, 1, 1 }, ``                      ``{ 1, 0, 0, 1, 0 } }; `` ` `    ``int` `K = 9, Q = 1; ``    ``int` `[]q_i = { 1 }; ``    ``int` `[]q_j = { 2 }; ``     ` `    ``largestSquare(matrix, 4, 5, q_i, ``                  ``q_j, K, Q); ``} ``}`` ` `// This code is contributed by princi singh`

## Javascript

 ``

Output :

`3`

The worst-case time complexity for the given solution is O(R*C + Q*MIN_DIST) where R, C is the dimensions of the initial matrix.

Efficient Approach using Dynamic Programming and Binary Search:
The idea is to use a Binary search to find the largest square instead of incrementing the length of a side iteratively and converge towards the side which gives at most K 1’s.
The search space for the binary search will be-

```// Minimum possible answer will be
// the square with side 0
l = 0

// Maximum possible will be to include
// the whole square possible from (i, j)
r = min(min(i, j),
min(R - i - 1, C - i - 1))```

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the ``// largest square in the matrix such``// that it contains atmost K 1's`` ` `#include ``using` `namespace` `std;``const` `int` `MAX = 100;`` ` `// Function to find the ``// largest square in the matrix such``// that it contains atmost K 1's``void` `largestSquare(``int` `matrix[][MAX], ``            ``int` `R, ``int` `C, ``int` `q_i[],``            ``int` `q_j[], ``int` `K, ``int` `Q){``     ` `    ``int` `countDP[R][C];``    ``memset``(countDP, 0, ``sizeof``(countDP));`` ` `    ``// Precomputation of the countDP``    ``// prefix sum of the matrix``    ``countDP[0][0] = matrix[0][0];``    ``for` `(``int` `i = 1; i < R; i++)``        ``countDP[i][0] = countDP[i - 1][0] +``                             ``matrix[i][0];``    ``for` `(``int` `j = 1; j < C; j++)``        ``countDP[0][j] = countDP[0][j - 1] +``                             ``matrix[0][j];``    ``for` `(``int` `i = 1; i < R; i++)``        ``for` `(``int` `j = 1; j < C; j++)``            ``countDP[i][j] = matrix[i][j] +``                       ``countDP[i - 1][j] +``                       ``countDP[i][j - 1] -``                   ``countDP[i - 1][j - 1];``     ` `    ``// Loop to solve each query``    ``for` `(``int` `q = 0; q < Q; q++) {``        ``int` `i = q_i[q];``        ``int` `j = q_j[q];``        ``int` `min_dist = min(min(i, j),``          ``min(R - i - 1, C - j - 1));``        ``int` `ans = -1, l = 0, u = min_dist;``         ` `        ``// Binary Search to the side which``        ``// have atmost in K 1's in square``        ``while` `(l <= u) {``            ``int` `mid = (l + u) / 2;``            ``int` `x1 = i - mid, x2 = i + mid;``            ``int` `y1 = j - mid, y2 = j + mid;``            ``// Count total number of 1s in``            ``// the sub square considered``            ``int` `count = countDP[x2][y2];``            ``if` `(x1 > 0)``                ``count -= countDP[x1 - 1][y2];``            ``if` `(y1 > 0)``                ``count -= countDP[x2][y1 - 1];``            ``if` `(x1 > 0 && y1 > 0)``                ``count += countDP[x1 - 1][y1 - 1];``             ` `            ``// If the count is less than or``            ``// equals to the maximum move``            ``// to right half``            ``if` `(count <= K) {``                ``ans = 2 * mid + 1;``                ``l = mid + 1;``            ``}``            ``else``                ``u = mid - 1;``        ``}``        ``cout << ans << ``"\n"``;``    ``}``}`` ` `int` `main()``{``    ``int` `matrix[][MAX] = { { 1, 0, 1, 0, 0 },``                        ``{ 1, 0, 1, 1, 1 },``                        ``{ 1, 1, 1, 1, 1 },``                        ``{ 1, 0, 0, 1, 0 } };`` ` `    ``int` `K = 9, Q = 1;``    ``int` `q_i[] = { 1 };``    ``int` `q_j[] = { 2 };``    ``largestSquare(matrix, 4, 5,``                ``q_i, q_j, K, Q);``    ``return` `0;``}`

## Java

 `// Java implementation to find the ``// largest square in the matrix such ``// that it contains atmost K 1's ``import` `java.util.*; `` ` `class` `GFG{`` ` `// Function to find the ``// largest square in the matrix such ``// that it contains atmost K 1's ``static` `void` `largestSquare(``int` `matrix[][], ``int` `R,``                          ``int` `C, ``int` `q_i[], ``                          ``int` `q_j[], ``int` `K, ``int` `Q)``{ ``    ``int` `countDP[][] = ``new` `int``[R][C]; ``    ``for``(``int` `i = ``0``; i < R; i++)``        ``for``(``int` `j = ``0``; j < C; j++)``            ``countDP[i][j] = ``0``; `` ` `    ``// Precomputation of the countDP ``    ``// prefix sum of the matrix ``    ``countDP[``0``][``0``] = matrix[``0``][``0``]; ``     ` `    ``for``(``int` `i = ``1``; i < R; i++) ``        ``countDP[i][``0``] = countDP[i - ``1``][``0``] + ``                             ``matrix[i][``0``]; ``     ` `    ``for``(``int` `j = ``1``; j < C; j++) ``        ``countDP[``0``][j] = countDP[``0``][j - ``1``] + ``                         ``matrix[``0``][j]; ``     ` `    ``for``(``int` `i = ``1``; i < R; i++) ``        ``for``(``int` `j = ``1``; j < C; j++) ``            ``countDP[i][j] = matrix[i][j] + ``                           ``countDP[i - ``1``][j] + ``                           ``countDP[i][j - ``1``] - ``                           ``countDP[i - ``1``][j - ``1``]; ``     ` `    ``// Loop to solve each query ``    ``for``(``int` `q = ``0``; q < Q; q++)``    ``{ ``        ``int` `i = q_i[q]; ``        ``int` `j = q_j[q]; ``         ` `        ``int` `min_dist = Math.min(Math.min(i, j), ``                                ``Math.min(R - i - ``1``,``                                         ``C - j - ``1``)); ``                                          ` `        ``int` `ans = -``1``, l = ``0``, u = min_dist; ``         ` `        ``// Binary Search to the side which ``        ``// have atmost in K 1's in square ``        ``while` `(l <= u)``        ``{ ``            ``int` `mid = (l + u) / ``2``; ``            ``int` `x1 = i - mid, x2 = i + mid; ``            ``int` `y1 = j - mid, y2 = j + mid; ``             ` `            ``// Count total number of 1s in ``            ``// the sub square considered ``            ``int` `count = countDP[x2][y2]; ``             ` `            ``if` `(x1 > ``0``) ``                ``count -= countDP[x1 - ``1``][y2]; ``            ``if` `(y1 > ``0``) ``                ``count -= countDP[x2][y1 - ``1``]; ``            ``if` `(x1 > ``0` `&& y1 > ``0``) ``                ``count += countDP[x1 - ``1``][y1 - ``1``]; ``             ` `            ``// If the count is less than or ``            ``// equals to the maximum move ``            ``// to right half ``            ``if` `(count <= K) ``            ``{ ``                ``ans = ``2` `* mid + ``1``; ``                ``l = mid + ``1``; ``            ``} ``            ``else``                ``u = mid - ``1``; ``        ``} ``        ``System.out.println(ans); ``    ``} ``} `` ` `// Driver code``public` `static` `void` `main(String args[]) ``{ ``    ``int` `matrix[][] = { { ``1``, ``0``, ``1``, ``0``, ``0` `}, ``                       ``{ ``1``, ``0``, ``1``, ``1``, ``1` `}, ``                       ``{ ``1``, ``1``, ``1``, ``1``, ``1` `}, ``                       ``{ ``1``, ``0``, ``0``, ``1``, ``0` `} }; `` ` `    ``int` `K = ``9``, Q = ``1``; ``    ``int` `q_i[] = {``1``}; ``    ``int` `q_j[] = {``2``}; ``     ` `    ``largestSquare(matrix, ``4``, ``5``, q_i, q_j, K, Q); ``} ``}`` ` `// This code is contributed by Stream_Cipher`

## Python3

 `# Python3 implementation to find the ``# largest square in the matrix such ``# that it contains atmost K 1's `` ` `# Function to find the ``# largest square in the matrix such ``# that it contains atmost K 1's ``def` `largestSquare(matrix, R, C, q_i, ``                     ``q_j, K, Q):``                          ` `    ``countDP ``=` `[[``0` `for` `x ``in` `range``(C)]``                  ``for` `x ``in` `range``(R)] ``     ` `    ``# Precomputing the countDP ``    ``# prefix sum of the matrix ``    ``countDP[``0``][``0``] ``=` `matrix[``0``][``0``] ``     ` `    ``for` `i ``in` `range``(``1``, R):``        ``countDP[i][``0``] ``=` `(countDP[i ``-` `1``][``0``] ``+``                              ``matrix[i][``0``])``    ``for` `j ``in` `range``(``1``, C):``        ``countDP[``0``][j] ``=` `(countDP[``0``][j ``-` `1``] ``+``                          ``matrix[``0``][j])``    ``for` `i ``in` `range``(``1``, R):``        ``for` `j ``in` `range``(``1``, C):``            ``countDP[i][j] ``=` `(matrix[i][j] ``+` `                            ``countDP[i ``-` `1``][j] ``+` `                            ``countDP[i][j ``-` `1``] ``-` `                            ``countDP[i ``-` `1``][j ``-` `1``])``     ` `    ``# Loop to solve Queries ``    ``for` `q ``in` `range``(``0``,Q):``        ``i ``=` `q_i[q]``        ``j ``=` `q_j[q]``         ` `        ``# Calculating the maximum ``        ``# possible distance of the ``        ``# centre from edge ``        ``min_dist ``=` `min``(i, j, R ``-` `i ``-` `1``, ``                             ``C ``-` `j ``-` `1``)``        ``ans ``=` `-``1``        ``l ``=` `0``        ``u ``=` `min_dist``         ` `        ``while` `(l <``=` `u):``            ``mid ``=` `int``((l ``+` `u) ``/` `2``) ``            ``x1 ``=` `i ``-` `mid``            ``x2 ``=` `i ``+` `mid ``            ``y1 ``=` `j ``-` `mid``            ``y2 ``=` `j ``+` `mid ``             ` `        ``# Count total number of 1s in ``        ``# the sub square considered ``            ``count ``=` `countDP[x2][y2]``             ` `            ``if` `(x1 > ``0``):``                    ``count ``-``=` `countDP[x1 ``-` `1``][y2] ``            ``if` `(y1 > ``0``):``                    ``count ``-``=` `countDP[x2][y1 ``-` `1``]``            ``if` `(x1 > ``0` `and` `y1 > ``0``): ``                    ``count ``+``=` `countDP[x1 ``-` `1``][y1 ``-` `1``]``             ` `        ``# If the count is less than or ``        ``# equals to the maximum move ``        ``# to right half ``            ``if` `(count <``=` `K): ``                    ``ans ``=` `2` `*` `mid ``+` `1``                    ``l ``=` `mid ``+` `1``            ``else``:``                ``u ``=` `mid ``-` `1``                 ` `        ``print``(ans)``         ` `# Driver Code ``matrix ``=` `[ [ ``1``, ``0``, ``1``, ``0``, ``0` `], ``           ``[ ``1``, ``0``, ``1``, ``1``, ``1` `], ``           ``[ ``1``, ``1``, ``1``, ``1``, ``1` `], ``           ``[ ``1``, ``0``, ``0``, ``1``, ``0` `] ] ``K ``=` `9``Q ``=` `1``q_i ``=` `[``1``] ``q_j ``=` `[``2``] `` ` `largestSquare(matrix, ``4``, ``5``, q_i, q_j, K, Q) `` ` `# This code is contributed by Stream_Cipher`

## C#

 `// C# implementation to find the ``// largest square in the matrix such ``// that it contains atmost K 1's ``using` `System.Collections.Generic; ``using` `System;`` ` `class` `GFG{`` ` `// Function to find the largest ``// square in the matrix such ``// that it contains atmost K 1's ``static` `void` `largestSquare(``int` `[,]matrix, ``int` `R,``                          ``int` `C, ``int` `[]q_i, ``                          ``int` `[]q_j, ``int` `K, ``int` `Q)``{ ``    ``int` `[,]countDP = ``new` `int``[R, C]; ``    ``for``(``int` `i = 0; i < R; i++)``        ``for``(``int` `j = 0; j < C; j++)``            ``countDP[i, j]=0; `` ` `    ``// Precomputation of the countDP ``    ``// prefix sum of the matrix ``    ``countDP[0, 0] = matrix[0, 0]; ``    ``for``(``int` `i = 1; i < R; i++) ``        ``countDP[i, 0] = countDP[i - 1, 0] + ``                         ``matrix[i, 0]; ``                          ` `    ``for``(``int` `j = 1; j < C; j++) ``        ``countDP[0, j] = countDP[0, j - 1] + ``                         ``matrix[0, j]; ``                          ` `    ``for``(``int` `i = 1; i < R; i++) ``        ``for``(``int` `j = 1; j < C; j++) ``            ``countDP[i, j] = matrix[i, j] + ``                           ``countDP[i - 1, j] + ``                           ``countDP[i, j - 1] - ``                           ``countDP[i - 1, j - 1]; ``     ` `    ``// Loop to solve each query ``    ``for``(``int` `q = 0; q < Q; q++)``    ``{ ``        ``int` `i = q_i[q]; ``        ``int` `j = q_j[q]; ``         ` `        ``int` `min_dist = Math.Min(Math.Min(i, j), ``                                ``Math.Min(R - i - 1,``                                         ``C - j - 1));``                                          ` `        ``int` `ans = -1, l = 0, u = min_dist; ``         ` `        ``// Binary Search to the side which ``        ``// have atmost in K 1's in square ``        ``while` `(l <= u) ``        ``{ ``            ``int` `mid = (l + u) / 2; ``            ``int` `x1 = i - mid, x2 = i + mid; ``            ``int` `y1 = j - mid, y2 = j + mid; ``             ` `            ``// Count total number of 1s in ``            ``// the sub square considered ``            ``int` `count = countDP[x2, y2];``             ` `            ``if` `(x1 > 0) ``                ``count -= countDP[x1 - 1, y2]; ``            ``if` `(y1 > 0) ``                ``count -= countDP[x2, y1 - 1]; ``            ``if` `(x1 > 0 && y1 > 0) ``                ``count += countDP[x1 - 1, y1 - 1]; ``             ` `            ``// If the count is less than or ``            ``// equals to the maximum move ``            ``// to right half ``            ``if` `(count <= K) ``            ``{ ``                ``ans = 2 * mid + 1; ``                ``l = mid + 1; ``            ``} ``            ``else``                ``u = mid - 1; ``        ``} ``        ``Console.WriteLine(ans); ``    ``} ``} `` ` `// Driver code``public` `static` `void` `Main() ``{ ``    ``int` `[,]matrix = { { 1, 0, 1, 0, 0 }, ``                      ``{ 1, 0, 1, 1, 1 }, ``                      ``{ 1, 1, 1, 1, 1 }, ``                      ``{ 1, 0, 0, 1, 0 } }; `` ` `    ``int` `K = 9, Q = 1; ``    ``int` `[]q_i = { 1 }; ``    ``int` `[]q_j = { 2 }; ``     ` `    ``largestSquare(matrix, 4, 5, ``                     ``q_i, q_j, K, Q); ``} ``}`` ` `// This code is contributed by Stream_Cipher`

## Javascript

 ``

Output:

`3`

Time Complexity: O( R*C + Q*log(MIN_DIST) )

My Personal Notes arrow_drop_up