Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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. 

maximum-size-square-sub-matrix-with-all-1s

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 <bits/stdc++.h>
#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<stdio.h>
#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



<?php
// PHP code for Maximum size square
// sub-matrix with all 1s
 
function printMaxSubSquare($M, $R, $C)
{
    $S = array(array()) ;
 
    /* 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--)
        {
            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



<script>
// JavaScript code for Maximum size square
// sub-matrix with all 1s
let R = 6;
let C = 5;
 
function printMaxSubSquare(M) {
    let i,j;
    let S = [];
 
for ( var y = 0; y < R; y++ ) {
    S[ y ] = [];
    for ( var x = 0; x < C; x++ ) {
        S[ y ][ x ] = 0;
    }
}
    let 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;
            }
        }            
    }
 
    document.write("Maximum size sub-matrix is: <br>");
    for(i = max_i; i > max_i - max_of_s; i--)
    {
        for(j = max_j; j > max_j - max_of_s; j--)
        {
            document.write( M[i][j] , " ");
        }
        document.write("<br>");
    }
}
 
 
/* Driver code */
let 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);
</script>
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. 
Algorithmic Paradigm: Dynamic Programming
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 <bits/stdc++.h>
 
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 entrie 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 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
    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



<script>
 
// JavaScript code for Maximum size square
// sub-matrix with all 1s
// (space optimized solution)
const R = 6
const C = 5
 
function printMaxSubSquare(M)
{
    let Max = 0
    let S = new Array(2)
   
    // set all elements of S to 0 first
    for(let i=0;i<2;i++){
        S[i] = new Array(C).fill(0)
    }
 
    // Construct the entries
    for (let i = 0; i < R;i++)
        for (let j = 0; j < C;j++){
 
            // Compute the entrie at the current position
            let Entrie = M[i][j];
            if(Entrie)
                if(j)
                    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
    document.write("Maximum size sub-matrix is: ","</br>")
    for (let i = 0; i < Max; i++){
        for (let j = 0; j < Max;j++)
            document.write("1 ")
        document.write("</br>")
    }
         
}
 
// Driver code
const 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
 
</script>
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
Previous
Maximum size rectangle binary sub-matrix with all 1s
Next

Longest Increasing Subsequence | DP-3
Recommended Articles
Page :
Find Maximum Length Of A Square Submatrix Having Sum Of Elements At-Most K
09, Jan 20
Largest possible square submatrix with maximum AND value
24, Jun 20
Submatrix of given size with maximum 1's
08, Apr 20
Maximum size of square such that all submatrices of that size have sum less than K
08, Apr 20
Check if a matrix contains a square submatrix with 0 as boundary element
31, May 20
Minimum operations to convert Binary Matrix A to B by flipping submatrix of size K
15, Oct 21
Smallest submatrix with Kth maximum XOR
01, Oct 20
Maximum value in a matrix which contain intersecting concentric submatrix
08, Jun 18
Maximum sum of any submatrix of a Matrix which is sorted row-wise and column-wise
10, Aug 20
Maximum sum submatrix
16, Feb 21
Submatrix Sum Queries
31, Jan 16
Summed Area Table - Submatrix Summation
24, Nov 16
Maximize the binary matrix by flipping submatrix once
24, Sep 17
XOR of a submatrix queries
15, Feb 19
Check if matrix A can be converted to B by changing parity of corner elements of any submatrix
12, Apr 19
Minimum cells to be flipped to get a 2*2 submatrix with equal elements
06, Dec 19
Count of submatrix with sum X in a given Matrix
09, Jul 20
Bitwise XOR of a submatrix of a matrix generated from a given array
21, Sep 20
Smallest submatrix required to be removed such that sum of the remaining matrix is divisible by K
13, Nov 20
Queries to count minimum flips required to fill a binary submatrix with 0s only
03, Dec 20
Minimum number of 1s present in a submatrix of given dimensions in a Binary Matrix
09, Mar 21
Minimum sum submatrix in a given 2D array
01, Nov 17
Maximum size square Sub-Matrix with sum less than or equals to K
21, Apr 20
Print maximum sum square sub-matrix of given size
13, May 16
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!