Skip to content
Related Articles

Related Articles

Improve Article

Sum of all Submatrices of a Given Matrix

  • Difficulty Level : Medium
  • Last Updated : 23 Aug, 2021

Given a NxN 2-D matrix, the task to find the sum of all the submatrices.

Examples: 

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 :  arr[] = {{1, 1},
                  {1, 1}};
Output : 16
Explanation: 
Number of sub-matrices with 1 elements = 4
Number of sub-matrices with 2 elements = 4
Number of sub-matrices with 3 elements = 0
Number of sub-matrices with 4 elements = 1

Since all the entries are 1, the sum becomes
sum = 1 * 4 + 2 * 4 + 3 * 0 + 4 * 1 = 16

Input : arr[] = {{1, 2, 3},
                 {4, 5, 6},
                 {7, 8, 9}}
Output : 500

Simple Solution: A naive solution is to generate all the possible submatrices and sum up all of them. 
The time complexity of this approach will be O(n6).



Efficient Solution : For each element of the matrix, let us try to find the number of sub-matrices, the element will lie in. 
This can be done in O(1) time. Let us suppose the index of an element be (X, Y) in 0 based indexing, then the number of submatrices (Sx, y) for this element will be in can be given by the formula Sx, y = (X + 1) * (Y + 1) * (N – X) * (N – Y). This formula works, because we just have to choose two different positions on the matrix that will create a submatrix that envelopes the element. Thus, for each element, ‘sum’ can be updated as sum += (Sx, y) * Arrx, y.

Below is the implementation of the above approach: 

Here we need to try to solve this question in the Reverse lookup  Technique:

1) For a particular element what are the possible submatrices where this element will be included.

2) When we get the number of possible submatrices then we can count the contribution of that particular element by doing ( a[i]* total number of submatrices where this will be included) where a[i] = current element

3) Now Question comes how to find the number of possible submatrices for a particular element.

 [[1 2 3]

  [4 5 6]



  [7 8 9]]

So let’s consider the current element as 5 , so for 5 there are (X+1)*(Y+1) choices where co-ordinates of submatrix starting point can lie,(Top Left)

Similarly, there will be (N-X)*(N-Y) choices where the end  co-ordinates of that submatrix can lie (Bottom Right)

 Number of choices for Top Left = (X+1)*(Y+1)

Number of choices for Bottom Right = (N-X)*(N-Y)

Total number of choices for the current element to be included in the submatrix will be : (X+1)*(Y+1) * (N-X)*(N-Y)

Contribution of the current element which can be included in all the possible submatrices will be  = arr[X][Y] * (X+1)*(Y+1) * (N-X)*(N-Y)

where X and Y  are index of the submatrices.

Time Complexity: O(N^2)

Space Complexity: O(1)

C++




// C++ program to find the sum of all
// possible submatrices of a given Matrix
 
#include <iostream>
#define n 3
using namespace std;
 
// Function to find the sum of all
// possible submatrices of a given Matrix
int matrixSum(int arr[][n])
{
    // Variable to store
    // the required sum
    int sum = 0;
 
    // Nested loop to find the number
    // of submatrices, each number belongs to
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
 
            // Number of ways to choose
            // from top-left elements
            int top_left = (i + 1) * (j + 1);
 
            // Number of ways to choose
            // from bottom-right elements
            int bottom_right = (n - i) * (n - j);
            sum += (top_left * bottom_right * arr[i][j]);
        }
 
    return sum;
}
 
// Driver Code
int main()
{
    int arr[][n] = { { 1, 1, 1 },
                     { 1, 1, 1 },
                     { 1, 1, 1 } };
 
    cout << matrixSum(arr);
 
    return 0;
}
Java



// Java program to find the sum of all
// possible submatrices of a given Matrix
class GFG
{
 
    static final int n = 3;
 
    // Function to find the sum of all
    // possible submatrices of a given Matrix
    static int matrixSum(int arr[][])
    {
        // Varialbe to store
        // the required sum
        int sum = 0;
 
        // Nested loop to find the number
        // of submatrices, each number belongs to
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
 
                // Number of ways to choose
                // from top-left elements
                int top_left = (i + 1) * (j + 1);
 
                // Number of ways to choose
                // from bottom-right elements
                int bottom_right = (n - i) * (n - j);
                sum += (top_left * bottom_right * arr[i][j]);
            }
        }
 
        return sum;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[][] = {{1, 1, 1},
        {1, 1, 1},
        {1, 1, 1}};
 
        System.out.println(matrixSum(arr));
    }
}
 
// This code contributed by Rajput-Ji
Python3



# Python3 program to find the sum of all
# possible submatrices of a given Matrix
n = 3
 
# Function to find the sum of all
# possible submatrices of a given Matrix
def matrixSum(arr) :
     
    # Variable to store the required sum
    sum = 0;
 
    # Nested loop to find the number of
    # submatrices, each number belongs to
    for i in range(n) :
        for j in range(n) :
 
            # Number of ways to choose
            # from top-left elements
            top_left = (i + 1) * (j + 1);
 
            # Number of ways to choose
            # from bottom-right elements
            bottom_right = (n - i) * (n - j);
            sum += (top_left * bottom_right *
                                  arr[i][j]);
 
    return sum;
 
# Driver Code
if __name__ == "__main__" :
    arr = [[ 1, 1, 1 ],
           [ 1, 1, 1 ],
           [ 1, 1, 1 ]];
 
    print(matrixSum(arr))
     
# This code is contributed by Ryuga
C#



// C# program to find the sum of all
// possible submatrices of a given Matrix
using System;
 
class GFG
{
static int n = 3;
 
// Function to find the sum of all
// possible submatrices of a given Matrix
static int matrixSum(int [,]arr)
{
    // Varialbe to store the
    // required sum
    int sum = 0;
 
    // Nested loop to find the number of 
    // submatrices, each number belongs to
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
 
            // Number of ways to choose
            // from top-left elements
            int top_left = (i + 1) * (j + 1);
 
            // Number of ways to choose
            // from bottom-right elements
            int bottom_right = (n - i) * (n - j);
            sum += (top_left * bottom_right * arr[i, j]);
        }
    }
 
    return sum;
}
 
// Driver Code
public static void Main()
{
    int [,]arr = {{1, 1, 1},
    {1, 1, 1},
    {1, 1, 1}};
 
    Console.WriteLine(matrixSum(arr));
}
}
 
// This code contributed by vt_m..
PHP



<?php
// PHP program to find the sum of all
// possible submatrices of a given Matrix
 
// Function to find the sum of all
// possible submatrices of a given Matrix
function matrixSum($arr)
{
    $n = 3;
     
    // Variable to store the required sum
    $sum = 0;
 
    // Nested loop to find the number
    // of submatrices, each number belongs to
    for ($i = 0; $i < $n; $i++)
        for ($j = 0; $j < $n; $j++)
        {
 
            // Number of ways to choose
            // from top-left elements
            $top_left = ($i + 1) * ($j + 1);
 
            // Number of ways to choose
            // from bottom-right elements
            $bottom_right = ($n - $i) * ($n - $j);
            $sum += ($top_left * $bottom_right *
                                 $arr[$i][$j]);
        }
 
    return $sum;
}
 
// Driver Code
$arr = array(array(1, 1, 1),
             array(1, 1, 1),
             array(1, 1, 1));
 
echo matrixSum($arr);
 
// This code is contributed
// by Akanksha Rai
?>
Javascript



<script>
 
// JavaScript program to find the sum of all
// possible submatrices of a given Matrix
 
let n = 3;
// Function to find the sum of all
// possible submatrices of a given Matrix
function matrixSum(arr)
{
    // Variable to store
    // the required sum
    let sum = 0;
 
    // Nested loop to find the number
    // of submatrices, each number belongs to
    for (let i = 0; i < n; i++)
        for (let j = 0; j < n; j++) {
 
            // Number of ways to choose
            // from top-left elements
            let top_left = (i + 1) * (j + 1);
 
            // Number of ways to choose
            // from bottom-right elements
            let bottom_right = (n - i) * (n - j);
            sum += (top_left * bottom_right * arr[i][j]);
        }
 
    return sum;
}
 
// Driver Code
let arr = [[ 1, 1, 1 ],
                     [ 1, 1, 1 ],
                     [ 1, 1, 1 ]] ;
 
 
    document.write(matrixSum(arr));
     
// This code is contributed by todaysgaurav
 
</script>
Output: 
100
 



My Personal Notes
arrow_drop_up
Previous
Submatrix Sum Queries
Next

Print maximum sum square sub-matrix of given size
Recommended Articles
Page :
Generate a matrix having each element equal to the sum of specified submatrices of a given matrix
03, Feb 21
Generate a matrix having even sum of all diagonals in each 2 x 2 submatrices
19, Jan 21
Smallest element from all square submatrices of size K from a given Matrix
05, Sep 20
Final Matrix after incrementing submatrices by K in range given by Q queries
27, Aug 20
Binary Matrix after flipping submatrices in given range for Q queries
27, Aug 20
Sum of bitwise AND of all submatrices
20, Feb 19
Sum of Bitwise-OR of all Submatrices
20, Feb 19
Maximum size of square such that all submatrices of that size have sum less than K
08, Apr 20
Median of Bitwise XOR of all submatrices starting from the top left corner
03, Jan 21
Number of submatrices with all 1s
18, Feb 19
Number of submatrices with OR value 1
18, Feb 19
Count of square submatrices with average at least K
07, Jul 21
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Generate matrix from given Sparse Matrix using Linked List and reconstruct the Sparse Matrix
19, Apr 21
Maximize sum of N X N upper left sub-matrix from given 2N X 2N matrix
28, Feb 17
Construct a Matrix such that each cell consists of sum of adjacent elements of respective cells in given Matrix
11, Nov 20
Check if a given matrix can be converted to another given matrix by row and column exchanges
30, Apr 20
Maximize sum of diagonal of a matrix by rotating all rows or all columns
17, Nov 20
Create matrix whose sum of diagonals in each sub matrix is even
13, Jul 20
Construct a square Matrix whose parity of diagonal sum is same as size of matrix
09, Aug 20
Maximize Matrix sum by replacing 0s such that Matrix remains sorted
29, Sep 21
Given an n x n square matrix, find sum of all sub-squares of size k x k
22, Sep 14
Sum of cost of all paths to reach a given cell in a Matrix
28, May 20
Minimize sum of an array having Bitwise AND of all its pairs present in a given matrix
09, Apr 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
DivyanshuShekhar1
@DivyanshuShekhar1
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