# Print cells with same rectangular sums in a matrix

Given a matrix of m x n matrix, we need to print all those cells at which sum of sub-matrix ended at this cell and sub-matrix starting at this cell is equal to remaining elements. For better understanding please see below diagram,

Examples :

```Input : mat[][] = {1, 2, 3, 5,
4, 1, 0, 2,
0, 1, 2, 0,
7, 1, 1, 0};
Output : (1, 1), (2, 2)

In above matrix, cell (1, 1) and cell (2, 2)
are our required cells because,
For cell (1, 1), sum of red and green areas is same
1+2+4+1+0+2+1+2+0+1+1+0 = 3+5+0+7
Same is true for cell (2, 2)
1+2+3+4+1+0+0+1+2+0+1+0 = 5+2+7+1

We need to print all blue boundary cells for
which sum of red area is equal to green area.

```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

First we construct auxiliary sub-matrices similar to the linked article.

We construct two matrices sum[][] and sumr[][] such that sum[i][j] denotes sum of sub-matrix from mat[0][0] to mat[i][j]. And sumr for storing sum till last indices i.e. sumr[i][j] denotes sum of sub-matrix, mat[i][j] to mat[m – 1][n – 1].
Now we can use above matrices for solving this problem, red area shown in above diagram can be calculated by adding corresponding cells from sum and sumr matrices, as mat[i][j] is considered twice while calculating this sum we will subtract it once to get sum of red area. Getting sum of remaining element, the green part, is pretty easy, we will just subtract sum of red part from total sum of given matrix.
So to check whether a particular cell satisfies the given condition we will calculate the sum of red part as explained above and compare it with total sum of matrix, if this sum is half of total sum, current cell satisfies the condition and hence a candidate for result.

## C/C++

 `// C++ program to print cells with same rectangular ` `// sum diagonally ` `#include ` `using` `namespace` `std; ` `#define R 4 ` `#define C 4 ` ` `  `// Method prints cell index at which rectangular sum is ` `// same at prime diagonal and other diagonal ` `void` `printCellWithSameRectangularArea(``int` `mat[R][C], ` `                                     ``int` `m, ``int` `n) ` `{ ` `    ``/* sum[i][j] denotes sum of sub-matrix, mat[0][0] ` `       ``to mat[i][j] ` `       ``sumr[i][j] denotes sum of sub-matrix, mat[i][j] ` `       ``to mat[m - 1][n - 1]  */` `    ``int` `sum[m][n], sumr[m][n]; ` ` `  `    ``//  Initialize both sum matrices by mat ` `    ``int` `totalSum = 0; ` `    ``for` `(``int` `i = 0; i < m; i++) ` `    ``{ ` `        ``for` `(``int` `j = 0; j < n; j++) ` `        ``{ ` `            ``sumr[i][j] = sum[i][j] = mat[i][j]; ` `            ``totalSum += mat[i][j]; ` `        ``} ` `    ``} ` ` `  `    ``//  updating first and last row separately ` `    ``for` `(``int` `i = 1; i < m; i++) ` `    ``{ ` `        ``sum[i][0] += sum[i-1][0]; ` `        ``sumr[m-i-1][n-1] += sumr[m-i][n-1]; ` `    ``} ` ` `  `    ``//  updating first and last column separately ` `    ``for` `(``int` `j = 1; j < n; j++) ` `    ``{ ` `        ``sum[0][j] += sum[0][j-1]; ` `        ``sumr[m-1][n-j-1] += sumr[m-1][n-j]; ` `    ``} ` ` `  `    ``//  updating sum and sumr indices by nearby indices ` `    ``for` `(``int` `i = 1; i < m; i++) ` `    ``{ ` `        ``for` `(``int` `j = 1; j < n; j++) ` `        ``{ ` `            ``sum[i][j] += sum[i-1][j] + sum[i][j-1] - ` `                                      ``sum[i-1][j-1]; ` `            ``sumr[m-i-1][n-j-1] += sumr[m-i][n-j-1] + ` `                                  ``sumr[m-i-1][n-j] - ` `                                  ``sumr[m-i][n-j]; ` `        ``} ` `    ``} ` ` `  `    ``//  Uncomment below code to print sum and reverse sum ` `    ``// matrix ` `    ``/* ` `        ``for (int i = 0; i < m; i++) ` `        ``{ ` `            ``for (int j = 0; j < n; j++) ` `            ``{ ` `                ``cout << sum[i][j] << " "; ` `            ``} ` `            ``cout << endl; ` `        ``} ` `        ``cout << endl; ` `        ``for (int i = 0; i < m; i++) ` `        ``{ ` `            ``for (int j = 0; j < n; j++) ` `            ``{ ` `                ``cout << sumr[i][j] << " "; ` `            ``} ` `            ``cout << endl; ` `        ``} ` `        ``cout << endl;    */` ` `  `    ``/* print all those indices at which sum of prime diagonal ` `       ``rectangles is half of the total sum of matrix  */` `    ``for` `(``int` `i = 0; i < m; i++) ` `    ``{ ` `        ``for` `(``int` `j = 0; j < n; j++) ` `        ``{ ` `            ``int` `mainDiagRectangleSum = sum[i][j] + sumr[i][j] - ` `                                                   ``mat[i][j]; ` `            ``if` `(totalSum == 2 * mainDiagRectangleSum) ` `                ``cout << ``"("` `<< i << ``", "` `<< j << ``")"` `<< endl; ` `        ``} ` `    ``} ` `} ` ` `  `//  Driver code to test above methods ` `int` `main() ` `{ ` `    ``int` `mat[R][C] = ` `    ``{ ` `        ``1, 2, 3, 5, ` `        ``4, 1, 0, 2, ` `        ``0, 1, 2, 0, ` `        ``7, 1, 1, 0 ` `    ``}; ` ` `  `    ``printCellWithSameRectangularArea(mat, R, C); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to print cells with  ` `// same rectangular sum diagonally ` ` `  `class` `GFG { ` `     `  `static` `final` `int` `R = ``4``; ` `static` `final` `int` `C = ``4``; ` ` `  `// Method prints cell index at which  ` `// rectangular sum is same at  ` `// prime diagonal and other diagonal ` `static` `void` `printCellWithSameRectangularArea(``int` `mat[][],  ` `                                             ``int` `m, ``int` `n)  ` `{ ` `    ``/* sum[i][j] denotes sum of sub-matrix, mat[0][0] ` `    ``to mat[i][j] ` `    ``sumr[i][j] denotes sum of sub-matrix, mat[i][j] ` `    ``to mat[m - 1][n - 1] */` `    ``int` `sum[][] = ``new` `int``[m][n]; ` `    ``int` `sumr[][] = ``new` `int``[m][n]; ` ` `  `    ``// Initialize both sum matrices by mat ` `    ``int` `totalSum = ``0``; ` `    ``for` `(``int` `i = ``0``; i < m; i++) { ` `    ``for` `(``int` `j = ``0``; j < n; j++) { ` `        ``sumr[i][j] = sum[i][j] = mat[i][j]; ` `        ``totalSum += mat[i][j]; ` `    ``} ` `    ``} ` ` `  `    ``// updating first and last row separately ` `    ``for` `(``int` `i = ``1``; i < m; i++) { ` `    ``sum[i][``0``] += sum[i - ``1``][``0``]; ` `    ``sumr[m - i - ``1``][n - ``1``] += sumr[m - i][n - ``1``]; ` `    ``} ` ` `  `    ``// updating first and last column separately ` `    ``for` `(``int` `j = ``1``; j < n; j++) { ` `    ``sum[``0``][j] += sum[``0``][j - ``1``]; ` `    ``sumr[m - ``1``][n - j - ``1``] += sumr[m - ``1``][n - j]; ` `    ``} ` ` `  `    ``// updating sum and sumr indices by nearby indices ` `    ``for` `(``int` `i = ``1``; i < m; i++) { ` `    ``for` `(``int` `j = ``1``; j < n; j++) { ` `        ``sum[i][j] += sum[i - ``1``][j] + sum[i][j - ``1``] -  ` `                                     ``sum[i - ``1``][j - ``1``]; ` `        ``sumr[m - i - ``1``][n - j - ``1``] += sumr[m - i][n - j - ``1``] + ` `                                      ``sumr[m - i - ``1``][n - j] - ` `                                      ``sumr[m - i][n - j]; ` `    ``} ` `    ``} ` ` `  `    ``// Uncomment below code to print sum and reverse sum ` `    ``// matrix ` `    ``/* ` `        ``for (int i = 0; i < m; i++) ` `        ``{ ` `            ``for (int j = 0; j < n; j++) ` `            ``{ ` `                ``System.out.print( sum[i][j] + " "); ` `            ``} ` `            ``System.out.println(); ` `        ``} ` `        ``System.out.println(); ` `        ``for (int i = 0; i < m; i++) ` `        ``{ ` `            ``for (int j = 0; j < n; j++) ` `            ``{ ` `                ``System.out.print(sumr[i][j] + " "); ` `            ``} ` `            ``System.out.println(); ` `        ``} ` `        ``System.out.println(); */` ` `  `    ``/* print all those indices at which sum of prime diagonal ` `    ``rectangles is half of the total sum of matrix */` `    ``for` `(``int` `i = ``0``; i < m; i++) { ` `    ``for` `(``int` `j = ``0``; j < n; j++) { ` `        ``int` `mainDiagRectangleSum = sum[i][j] +  ` `                       ``sumr[i][j] - mat[i][j]; ` `        ``if` `(totalSum == ``2` `* mainDiagRectangleSum) ` `        ``System.out.println(``"("` `+ i + ``", "` `+ j + ``")"``); ` `    ``} ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `mat[][] = {{``1``, ``2``, ``3``, ``5``}, ` `                   ``{``4``, ``1``, ``0``, ``2``},  ` `                   ``{``0``, ``1``, ``2``, ``0``},  ` `                   ``{``7``, ``1``, ``1``, ``0``}}; ` ` `  `    ``printCellWithSameRectangularArea(mat, R, C); ` `} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python

 `# Python program to print cells with same rectangular ` `# sum diagonally ` `# R 4 ` `# C 4 ` `  `  `# Method prints cell index at which rectangular sum is ` `# same at prime diagonal and other diagonal ` `def` `printCellWithSameRectangularArea(mat, m, n): ` `    ``# sum[i][j] denotes sum of sub-matrix, mat[0][0] ` `    ``#  to mat[i][j] ` `    ``# sumr[i][j] denotes sum of sub-matrix, mat[i][j] ` `    ``# to mat[m - 1][n - 1]   ` `    ``sum` `=` `[[``0` `for` `i ``in` `range``(m)]``for` `j ``in` `range``(n)] ` `    ``sumr ``=` `[[``0` `for` `i ``in` `range``(m)]``for` `j ``in` `range``(n)] ` `  `  `    ``#  Initialize both sum matrices by mat ` `    ``totalSum ``=` `0` `    ``for` `i ``in` `range``(m): ` `        ``for` `j ``in` `range``(n): ` `            ``sumr[i][j] ``=` `sum``[i][j] ``=` `mat[i][j]; ` `            ``totalSum ``+``=` `mat[i][j] ` `  `  `    ``#  updating first and last row separately ` `    ``for` `i ``in` `range``(``1``,m): ` `        ``sum``[i][``0``] ``+``=` `sum``[i``-``1``][``0``] ` `        ``sumr[m``-``i``-``1``][n``-``1``] ``+``=` `sumr[m``-``i][n``-``1``] ` `  `  `    ``#  updating first and last column separately ` `    ``for` `j ``in` `range``(``1``,n): ` `        ``sum``[``0``][j] ``+``=` `sum``[``0``][j``-``1``]; ` `        ``sumr[m``-``1``][n``-``j``-``1``] ``+``=` `sumr[m``-``1``][n``-``j] ` `  `  `    ``#  updating sum and sumr indices by nearby indices ` `    ``for` `i ``in` `range``(``1``,m): ` `        ``for` `j ``in` `range``(``1``,n): ` `            ``sum``[i][j] ``+``=` `sum``[i``-``1``][j] ``+` `sum``[i][j``-``1``] ``-` `sum``[i``-``1``][j``-``1``] ` `            ``sumr[m``-``i``-``1``][n``-``j``-``1``] ``+``=` `sumr[m``-``i][n``-``j``-``1``] ``+` `sumr[m``-``i``-``1``][n``-``j] ``-` `sumr[m``-``i][n``-``j] ` `  `  `    ``#  Uncomment below code to print sum and reverse sum ` `    ``# matrix ` `  `  `    ``# print all those indices at which sum of prime diagonal ` `    ``#   rectangles is half of the total sum of matrix   ` `    ``for` `i ``in` `range``(m): ` `        ``for` `j ``in` `range``(n): ` `            ``mainDiagRectangleSum ``=` `sum``[i][j] ``+` `sumr[i][j] ``-` `mat[i][j] ` `            ``if` `(totalSum ``=``=` `2` `*` `mainDiagRectangleSum): ` `                ``print` `"("``, ` `                ``print` `i, ` `                ``print` `","``, ` `                ``print` `j, ` `                ``print` `")"``, ` `  `  `#  Driver code to test above methods ` `mat ``=``[[``1``, ``2``, ``3``, ``5``,], ` `     ``[``4``, ``1``, ``0``, ``2``,], ` `     ``[``0``, ``1``, ``2``, ``0``], ` `     ``[``7``, ``1``, ``1``, ``0``]] ` `printCellWithSameRectangularArea(mat, ``4``, ``4``) ` ` `  `# Contributed by Afzal `

## C#

 `// C# program to print cells with  ` `// same rectangular sum diagonally ` `using` `System; ` ` `  `class` `GFG { ` `     `  `static` `int` `R = 4; ` `static` `int` `C = 4; ` ` `  `// Method prints cell index at which  ` `// rectangular sum is same at  ` `// prime diagonal and other diagonal ` `static` `void` `printCellWithSameRectangularArea(``int` `[,]mat,  ` `                                             ``int` `m, ``int` `n)  ` `{ ` `    ``/* sum[i][j] denotes sum of sub- ` `       ``matrix, mat[0][0] to mat[i][j] ` `       ``sumr[i][j] denotes sum of sub-matrix, ` `       ``mat[i][j] to mat[m - 1][n - 1] */` `    ``int` `[,]sum = ``new` `int``[m, n]; ` `    ``int` `[,]sumr = ``new` `int``[m, n]; ` ` `  `    ``// Initialize both sum matrices by mat ` `    ``int` `totalSum = 0; ` `    ``for` `(``int` `i = 0; i < m; i++) { ` `    ``for` `(``int` `j = 0; j < n; j++) { ` `        ``sumr[i, j] = sum[i, j] = mat[i, j]; ` `        ``totalSum += mat[i, j]; ` `    ``} ` `    ``} ` ` `  `    ``// updating first and last row separately ` `    ``for` `(``int` `i = 1; i < m; i++) ` `    ``{ ` `    ``sum[i, 0] += sum[i - 1, 0]; ` `    ``sumr[m - i - 1, n - 1] += sumr[m - i, n - 1]; ` `    ``} ` ` `  `    ``// updating first and last column separately ` `    ``for` `(``int` `j = 1; j < n; j++)  ` `    ``{ ` `    ``sum[0,j] += sum[0,j - 1]; ` `    ``sumr[m - 1,n - j - 1] += sumr[m - 1,n - j]; ` `    ``} ` ` `  `    ``// updating sum and sumr indices by nearby indices ` `    ``for` `(``int` `i = 1; i < m; i++) { ` `    ``for` `(``int` `j = 1; j < n; j++) { ` `        ``sum[i,j] += sum[i - 1,j] + sum[i,j - 1] -  ` `                                   ``sum[i - 1,j - 1]; ` `        ``sumr[m - i - 1,n - j - 1] += sumr[m - i,n - j - 1] + ` `                                     ``sumr[m - i - 1,n - j] - ` `                                     ``sumr[m - i,n - j]; ` `    ``} ` `    ``} ` ` `  `    ``// Uncomment below code to print sum and reverse sum ` `    ``// matrix ` `    ``/* ` `        ``for (int i = 0; i < m; i++) ` `        ``{ ` `            ``for (int j = 0; j < n; j++) ` `            ``{ ` `                ``System.out.print( sum[i][j] + " "); ` `            ``} ` `            ``System.out.println(); ` `        ``} ` `        ``System.out.println(); ` `        ``for (int i = 0; i < m; i++) ` `        ``{ ` `            ``for (int j = 0; j < n; j++) ` `            ``{ ` `                ``System.out.print(sumr[i][j] + " "); ` `            ``} ` `            ``System.out.println(); ` `        ``} ` `        ``System.out.println(); */` ` `  `    ``/* print all those indices at which sum ` `       ``of prime diagonal rectangles is half  ` `       ``of the total sum of matrix */` `    ``for` `(``int` `i = 0; i < m; i++) { ` `    ``for` `(``int` `j = 0; j < n; j++) { ` `        ``int` `mainDiagRectangleSum = sum[i,j] +  ` `                    ``sumr[i,j] - mat[i,j]; ` `                     `  `        ``if` `(totalSum == 2 * mainDiagRectangleSum) ` `        ``Console.WriteLine(``"("` `+ i + ``", "` `+ j + ``")"``); ` `    ``} ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[,]mat = {{1, 2, 3, 5}, ` `                  ``{4, 1, 0, 2},  ` `                  ``{0, 1, 2, 0},  ` `                  ``{7, 1, 1, 0}}; ` ` `  `    ``printCellWithSameRectangularArea(mat, R, C); ` `} ` `} ` ` `  `// This code is contributed by vt_m. `

Output:

```(1, 1)
(2, 2)
```

This article is contributed by Utkarsh Trivedi. 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.

My Personal Notes arrow_drop_up

Improved By : vt_m

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.