Count all square sub-matrix with sum greater than the given number S

Given a matrix mat[][] and two integers K and S, the task is to count all K x K sub-matrix such that the sum of all the elements in sub-matrix is greater than or equal to S.
Examples: 
 

Input: K = 2, S = 15
mat[][] = {{1, 2, 3}, 
           {4, 5, 6},
           {7, 8, 9}} 
Output: 3
Explanation:
In the given matrix there are 3 sub-matrix
Sub-Matrix 1: (0, 1) to (1, 2)
Sum = 2 + 3 + 5 + 6 = 16
Sub-matrix 2: (1, 0) to (2, 1)
Sum = 4 + 5 + 7 + 8 = 24
Sub-matrix 3: (1, 1) to (2, 2)
Sum = 5 + 6 + 8 + 9 = 28

Input: K = 3, S = 35
arr[][] = {{1, 7, 1, 1, 1}, 
           {2, 2, 2, 2, 2}, 
           {3, 9, 6, 7, 3}, 
           {4, 3, 2, 4, 5}, 
           {5, 1, 5, 3, 1}}
Output: 5

 

Naive Approach: Iterate over all the possible sub-matrix of size K x K and find the sum of each matrix. If the sum of the any sub-matrix is greater than the given sum S, then increment the count by 1.
Efficient Approach: The idea is to precompute the prefix sum of the matrix such that the sum of every sub-matrix sum can be computed in O(1) time. Finally, Iterate over all the possible positions of the matrix and check the sum of the sub-matrix of size K x K from that positions with inclusion and exclusion principle. If the sum is greater than the given sum then increment the count of such sub-matrix by 1.
Below is the implementation of the above approach: 
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ programm to count total number
// of k x k sub matrix whose sum is
// greater than the given number S
  
#include <iostream>
  
using namespace std;
  
#define dim 5
  
// Function to create Prefix sum 
// matrix from the given matrix
void createTable(int mtrx[][dim], 
     int k, int p, int dp[][dim])
{
    // Store first value in table
    dp[0][0] = mtrx[0][0];
      
    // Initialize first row of matrix
    for (int j = 1; j < dim; j++) {
        dp[0][j] = mtrx[0][j] + 
                 dp[0][j - 1];
    }
      
    // Initialize first coloumn of matrix
    for (int i = 1; i < dim; i++) {
        dp[i][0] = mtrx[i][0] + 
                 dp[i - 1][0];
    }
      
    // Initialize rest table with sum 
    for (int i = 1; i < dim; i++) {
        for (int j = 1; j < dim; j++) {
            dp[i][j] = mtrx[i][j] + 
               dp[i - 1][j] + dp[i][j - 1] - 
                          dp[i - 1][j - 1];
        }
    }
}
  
// Utility Function to count the submatrix
// whose sum is greater than the S
int countSubMatrixUtil(int dp[][dim], 
                        int k, int p)
{
    int count = 0;
    int subMatSum = 0;
      
    // Loop to iterate over all the
    // possible positions of the 
    // given matrix mat[][]
    for (int i = k - 1; i < dim; i++) {
        for (int j = k - 1; j < dim; 
                                j++) {
            if (i == (k - 1) || j == (k - 1)) {
                  
                // Condition to check, if K x K
                // is first sub matrix 
                if (i == (k - 1) && j == (k - 1)) {
                    subMatSum = dp[i][j];
                }
                // Condition to check sub-matrix 
                // has no margin at top
                else if (i == (k - 1)) {
                    subMatSum = dp[i][j] - dp[i][j - k];
                }
                // Condition when sub matrix 
                // has no margin at left
                else {
                    subMatSum = dp[i][j] - dp[i - k][j];
                }
            }
            // Condtion when submatrix has 
            // margin at top and left
            else {
                subMatSum = dp[i][j] - dp[i - k][j] - 
                    dp[i][j - k] + dp[i - k][j - k];
            }
              
            // Increament count, If sub matrix
            // sum is greater than S
            if (subMatSum >= p) {
                count++;
            }
        }
    }
    return count;
}
// Function to count submatrix of
// size k x k such that sum if 
// greater than or equal to S
int countSubMatrix(int mtrx[][dim], int k, int p)
{
    int dp[dim][dim];
      
    // For loop to initialize prefix sum 
    // matrix with zero, initially
    for (int i = 0; i < dim; i++) {
        for (int j = 0; j < dim; j++) {
            dp[i][j] = 0;
        }
    }
      
    // Function to create the 
    // prefix sum  matrix
    createTable(mtrx, k, p, dp);
    return countSubMatrixUtil(dp, k, p);
}
  
// Driver Code
int main()
{
    int mtrx[dim][dim] = {
        { 1, 7, 1, 1, 1 },
        { 2, 2, 2, 2, 2 },
        { 3, 9, 6, 7, 3 },
        { 4, 3, 2, 4, 5 },
        { 5, 1, 5, 3, 1 }
    };
    int k = 3;
    int p = 35;
  
    // Print total number of sub matrix
    cout << countSubMatrix(mtrx, k, p);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count total number
// of k x k sub matrix whose sum is
// greater than the given number S
import java.util.*;
  
class GFG{
  
static final int dim = 5;
  
// Function to create prefix sum 
// matrix from the given matrix
static void createTable(int mtrx[][], 
                        int k, int p,
                        int dp[][])
{
      
    // Store first value in table
    dp[0][0] = mtrx[0][0];
      
    // Initialize first row of matrix
    for(int j = 1; j < dim; j++) 
    {
        dp[0][j] = mtrx[0][j] + 
                     dp[0][j - 1];
    }
      
    // Initialize first coloumn of matrix
    for(int i = 1; i < dim; i++) 
    {
        dp[i][0] = mtrx[i][0] + 
                 dp[i - 1][0];
    }
      
    // Initialize rest table with sum 
    for(int i = 1; i < dim; i++) 
    {
        for(int j = 1; j < dim; j++) 
        {
            dp[i][j] = mtrx[i][j] + 
                         dp[i - 1][j] + 
                         dp[i][j - 1] - 
                         dp[i - 1][j - 1];
        }
    }
}
  
// Utility Function to count the submatrix
// whose sum is greater than the S
static int countSubMatrixUtil(int dp[][], 
                              int k, int p)
{
    int count = 0;
    int subMatSum = 0;
      
    // Loop to iterate over all the
    // possible positions of the 
    // given matrix mat[][]
    for(int i = k - 1; i < dim; i++)
    {
        for(int j = k - 1; j < dim; j++)
        {
            if (i == (k - 1) || j == (k - 1))
            {
                  
                // Condition to check, if K x K
                // is first sub matrix 
                if (i == (k - 1) && j == (k - 1))
                {
                    subMatSum = dp[i][j];
                }
                  
                // Condition to check sub-matrix 
                // has no margin at top
                else if (i == (k - 1))
                {
                    subMatSum = dp[i][j] -
                                dp[i][j - k];
                }
                  
                // Condition when sub matrix 
                // has no margin at left
                else
                {
                    subMatSum = dp[i][j] - 
                                dp[i - k][j];
                }
            }
              
            // Condtion when submatrix has 
            // margin at top and left
            else 
            {
                subMatSum = dp[i][j] - dp[i - k][j] - 
                            dp[i][j - k] + 
                            dp[i - k][j - k];
            }
              
            // Increament count, If sub matrix
            // sum is greater than S
            if (subMatSum >= p)
            {
                count++;
            }
        }
    }
    return count;
}
  
// Function to count submatrix of
// size k x k such that sum if 
// greater than or equal to S
static int countSubMatrix(int mtrx[][], 
                          int k, int p)
{
    int [][]dp = new int[dim][dim];
      
    // For loop to initialize prefix sum 
    // matrix with zero, initially
    for(int i = 0; i < dim; i++) 
    {
        for(int j = 0; j < dim; j++) 
        {
            dp[i][j] = 0;
        }
    }
      
    // Function to create the 
    // prefix sum matrix
    createTable(mtrx, k, p, dp);
      
    return countSubMatrixUtil(dp, k, p);
}
  
// Driver Code
public static void main(String[] args)
{
    int mtrx[][] = { { 1, 7, 1, 1, 1 },
                     { 2, 2, 2, 2, 2 },
                     { 3, 9, 6, 7, 3 },
                     { 4, 3, 2, 4, 5 },
                     { 5, 1, 5, 3, 1 } };
    int k = 3;
    int p = 35;
  
    // Print total number of sub matrix
    System.out.print(countSubMatrix(mtrx, k, p));
}
}
  
// This code is contributed by Rohit_ranjan

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 programm to count total number
# of k x k sub matrix whose sum is
# greater than the given number S
  
dim = 5
  
# Function to create prefix sum 
# matrix from the given matrix
def createTable(mtrx, k, p, dp):
      
    # Store first value in table
    dp[0][0] = mtrx[0][0]
      
    # Initialize first row of matrix
    for j in range(1, dim):
        dp[0][j] = mtrx[0][j] + dp[0][j - 1]
      
    # Initialize first coloumn of matrix
    for i in range(1, dim):
        dp[i][0] = mtrx[i][0] + dp[i - 1][0]
      
    # Initialize rest table with sum 
    for i in range(1, dim):
        for j in range(1, dim):
            dp[i][j] = (mtrx[i][j] + 
                        dp[i - 1][j] +
                        dp[i][j - 1] - 
                        dp[i - 1][j - 1])
          
# Utility function to count the submatrix
# whose sum is greater than the S
def countSubMatrixUtil(dp, k, p):
      
    count = 0
    subMatSum = 0
      
    # Loop to iterate over all the
    # possible positions of the 
    # given matrix mat[][]
    for i in range(k - 1, dim):
        for j in range(k - 1, dim, 1):
            if (i == (k - 1) or j == (k - 1)):
                  
                # Condition to check, if K x K
                # is first sub matrix 
                if (i == (k - 1) and j == (k - 1)):
                    subMatSum = dp[i][j]
                      
                # Condition to check sub-matrix 
                # has no margin at top
                elif (i == (k - 1)):
                    subMatSum = dp[i][j] - dp[i][j - k]
                      
                # Condition when sub matrix 
                # has no margin at left
                else:
                    subMatSum = dp[i][j] - dp[i - k][j]
                      
            # Condtion when submatrix has 
            # margin at top and left
            else:
                subMatSum = (dp[i][j] -
                             dp[i - k][j] - 
                             dp[i][j - k] + 
                             dp[i - k][j - k])
              
            # Increament count, If sub matrix
            # sum is greater than S
            if (subMatSum >= p):
                count += 1
                  
    return count
      
# Function to count submatrix of
# size k x k such that sum if 
# greater than or equal to S
def countSubMatrix(mtrx, k, p):
      
    dp = [[0 for i in range(dim)] 
             for j in range(dim)]
      
    # For loop to initialize prefix sum 
    # matrix with zero, initially
    for i in range(dim):
        for j in range(dim):
            dp[i][j] = 0
      
    # Function to create the 
    # prefix sum matrix
    createTable(mtrx, k, p, dp)
      
    return countSubMatrixUtil(dp, k, p)
  
# Driver Code
if __name__ == '__main__':
      
    mtrx = [ [ 1, 7, 1, 1, 1 ],
             [ 2, 2, 2, 2, 2 ],
             [ 3, 9, 6, 7, 3 ],
             [ 4, 3, 2, 4, 5 ],
             [ 5, 1, 5, 3, 1 ] ]
    k = 3
    p = 35
  
    # Print total number of sub matrix
    print(countSubMatrix(mtrx, k, p))
  
# This code is contributed by Bhupendra_Singh

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to count total number
// of k x k sub matrix whose sum is
// greater than the given number S
using System;
  
class GFG{
  
static readonly int dim = 5;
  
// Function to create prefix sum 
// matrix from the given matrix
static void createTable(int [,]mtrx, 
                        int k, int p,
                        int [,]dp)
{
      
    // Store first value in table
    dp[0, 0] = mtrx[0, 0];
      
    // Initialize first row of matrix
    for(int j = 1; j < dim; j++) 
    {
        dp[0, j] = mtrx[0, j] + 
                     dp[0, j - 1];
    }
      
    // Initialize first coloumn of matrix
    for(int i = 1; i < dim; i++) 
    {
        dp[i, 0] = mtrx[i, 0] + 
                 dp[i - 1, 0];
    }
      
    // Initialize rest table with sum 
    for(int i = 1; i < dim; i++) 
    {
        for(int j = 1; j < dim; j++) 
        {
            dp[i, j] = mtrx[i, j] + 
                         dp[i - 1, j] + 
                         dp[i, j - 1] - 
                         dp[i - 1, j - 1];
        }
    }
}
  
// Utility Function to count the submatrix
// whose sum is greater than the S
static int countSubMatrixUtil(int [,]dp, 
                              int k, int p)
{
    int count = 0;
    int subMatSum = 0;
      
    // Loop to iterate over all the
    // possible positions of the 
    // given matrix [,]mat
    for(int i = k - 1; i < dim; i++)
    {
        for(int j = k - 1; j < dim; j++)
        {
            if (i == (k - 1) || j == (k - 1))
            {
                  
                // Condition to check, if K x K
                // is first sub matrix 
                if (i == (k - 1) && j == (k - 1))
                {
                    subMatSum = dp[i, j];
                }
                  
                // Condition to check sub-matrix 
                // has no margin at top
                else if (i == (k - 1))
                {
                    subMatSum = dp[i, j] -
                                dp[i, j - k];
                }
                  
                // Condition when sub matrix 
                // has no margin at left
                else
                {
                    subMatSum = dp[i, j] - 
                                dp[i - k, j];
                }
            }
              
            // Condtion when submatrix has 
            // margin at top and left
            else
            {
                subMatSum = dp[i, j] - dp[i - k, j] - 
                            dp[i, j - k] + 
                            dp[i - k, j - k];
            }
              
            // Increament count, If sub matrix
            // sum is greater than S
            if (subMatSum >= p)
            {
                count++;
            }
        }
    }
    return count;
}
  
// Function to count submatrix of
// size k x k such that sum if 
// greater than or equal to S
static int countSubMatrix(int [,]mtrx, 
                          int k, int p)
{
    int [,]dp = new int[dim, dim];
      
    // For loop to initialize prefix sum 
    // matrix with zero, initially
    for(int i = 0; i < dim; i++) 
    {
        for(int j = 0; j < dim; j++) 
        {
            dp[i, j] = 0;
        }
    }
      
    // Function to create the 
    // prefix sum matrix
    createTable(mtrx, k, p, dp);
      
    return countSubMatrixUtil(dp, k, p);
}
  
// Driver Code
public static void Main(String[] args)
{
    int [,]mtrx = { { 1, 7, 1, 1, 1 },
                    { 2, 2, 2, 2, 2 },
                    { 3, 9, 6, 7, 3 },
                    { 4, 3, 2, 4, 5 },
                    { 5, 1, 5, 3, 1 } };
    int k = 3;
    int p = 35;
  
    // Print total number of sub matrix
    Console.Write(countSubMatrix(mtrx, k, p));
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output: 

5

 

Time Complexity: O(M * N) 
Auxiliary Space: O(M * N)
 

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.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.