# Count right angled triangles in a matrix having two of its sides parallel to sides of the matrix

Given a binary matrix arr[][] of dimensions N * M , the task is to count the number of right-angled triangles that can be formed by joining the cells containing the value 1 such that the triangles must have any two of its sides parallel to the sides of the rectangle.

Examples:

Input: arr[][] = {{0, 1, 0}, {1, 1, 1}, {0, 1, 0}}
Output: 4
Explanation: Right-angled triangles that can be formed are (a, a, a), (a, a, a), (a, a, a) and (a, a, a)

Input: arr[][] = {{1, 0, 1, 0}, {0, 1, 1, 1}, {1, 0, 1, 0}, {0, 1, 0, 1}}
Output: 16

Approach: The idea is to traverse the given grid and store the count of 1s present in each row and each column in auxiliary arrays row[] and col[] respectively. Then for each cell in the grid arr[][], if arr[i][j] is 1, then the total number of right-angled triangles formed can be calculated by (row[i] – 1)*(col[j] – 1) for each cell. Follow the steps below to solve the problem:

• Initialize the arrays col[] and row[] with 0.
• Traverse the given grid and visit every cell arr[i][j].
• If arr[i][j] is 1, increment row[i] and col[j] by 1.
• After traversing the grid, initialize a variable ans with 0.
• Again traverse the whole grid and now, if arr[i][j] is 1 then update the count of the right-angled triangle by:

(row[i] – 1)*(col[j] – 1)

• After traversing, print the value of ans as the total number of right-angled triangles.

Below is the implementation for the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to count the right-angled` `// traingle in the given grid a[][]` `int` `numberOfTriangle(` `    ``vector >& a)` `{` `    ``int` `N = a.size();` `    ``int` `M = a.size();`   `    ``// Stores the count of 1s for` `    ``// each row[] and column[]` `    ``int` `rows[N] = { 0 };` `    ``int` `columns[M] = { 0 };`   `    ``// Find the number of 1s in` `    ``// each of the rows[0, N - 1]` `    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``for` `(``int` `j = 0; j < M; ++j) {`   `            ``// Increment row[i]` `            ``if` `(a[i][j] == 1) {` `                ``rows[i]++;` `            ``}` `        ``}` `    ``}`   `    ``// Find the number of 1s in` `    ``// each of the columns[0, N - 1]` `    ``for` `(``int` `i = 0; i < M; ++i) {`   `        ``for` `(``int` `j = 0; j < N; ++j) {`   `            ``// Increment columns[i]` `            ``if` `(a[j][i] == 1) {` `                ``columns[i]++;` `            ``}` `        ``}` `    ``}`   `    ``// Stores the count of triangles` `    ``int` `answer = 0;`   `    ``for` `(``int` `i = 0; i < N; ++i) {` `        ``for` `(``int` `j = 0; j < M; ++j) {`   `            ``// If current cell has value 1` `            ``if` `(a[i][j] == 1) {`   `                ``// Update the answer` `                ``answer += (rows[i] - 1)` `                          ``* (columns[j] - 1);` `            ``}` `        ``}`   `       `  `    ``}` `   ``// Return the count` `        ``return` `answer;` `}`     `// Driver Code` `int` `main()` `{` `    ``// Given grid arr[][]` `    ``vector > arr;`   `    ``arr = { { 1, 0, 1, 0 },` `            ``{ 0, 1, 1, 1 },` `            ``{ 1, 0, 1, 0 },` `            ``{ 0, 1, 0, 1 } };`   `    ``// Function Call` `    ``cout << numberOfTriangle(arr);`   `    ``return` `0;` `}`

## Java

 `// Java program for the` `// above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to count the right-angled` `// traingle in the given grid a[][]` `static` `int` `numberOfTriangle(``int``[][] a)` `{` `  ``int` `N = a.length;` `  ``int` `M = a[``0``].length;`   `  ``// Stores the count of 1s for` `  ``// each row[] and column[]` `  ``int` `[]rows = ``new` `int``[N];` `  ``int` `[]columns = ``new` `int``[M];`   `  ``// Find the number of 1s in` `  ``// each of the rows[0, N - 1]` `  ``for` `(``int` `i = ``0``; i < N; ++i) ` `  ``{` `    ``for` `(``int` `j = ``0``; j < M; ++j) ` `    ``{` `      ``// Increment row[i]` `      ``if` `(a[i][j] == ``1``) ` `      ``{` `        ``rows[i]++;` `      ``}` `    ``}` `  ``}`   `  ``// Find the number of 1s in` `  ``// each of the columns[0, N - 1]` `  ``for` `(``int` `i = ``0``; i < M; ++i) ` `  ``{` `    ``for` `(``int` `j = ``0``; j < N; ++j) ` `    ``{` `      ``// Increment columns[i]` `      ``if` `(a[j][i] == ``1``) ` `      ``{` `        ``columns[i]++;` `      ``}` `    ``}` `  ``}`   `  ``// Stores the count ` `  ``// of triangles` `  ``int` `answer = ``0``;`   `  ``for` `(``int` `i = ``0``; i < N; i++) ` `  ``{` `    ``for` `(``int` `j = ``0``; j < M; ++j) ` `    ``{` `      ``// If current cell ` `      ``// has value 1` `      ``if` `(a[i][j] == ``1``) ` `      ``{` `        ``// Update the answer` `        ``answer += (rows[i] - ``1``) * ` `                  ``(columns[j] - ``1``);` `      ``}` `    ``}` `  ``}`   `  ``// Return the count` `  ``return` `answer;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Given grid arr[][]` `  ``int` `[][]arr = {{``1``, ``0``, ``1``, ``0``},` `                 ``{``0``, ``1``, ``1``, ``1``},` `                 ``{``1``, ``0``, ``1``, ``0``},` `                 ``{``0``, ``1``, ``0``, ``1``}};`   `  ``// Function Call` `  ``System.out.print(numberOfTriangle(arr));` `}` `}`   `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program for the above approach`   `# Function to count the right-angled` `# traingle in the given grid a[][]` `def` `numberOfTriangle(a):` `    `  `    ``N ``=` `len``(a)` `    ``M ``=` `len``(a[``0``])`   `    ``# Stores the count of 1s for` `    ``# each row[] and column[]` `    ``rows ``=` `[``0``] ``*` `N` `    ``columns ``=` `[``0``] ``*` `M`   `    ``# Find the number of 1s in` `    ``# each of the rows[0, N - 1]` `    ``for` `i ``in` `range``(N):` `        ``for` `j ``in` `range``(M):`   `            ``# Increment row[i]` `            ``if` `(a[i][j] ``=``=` `1``):` `                ``rows[i] ``+``=` `1`   `    ``# Find the number of 1s in` `    ``# each of the columns[0, N - 1]` `    ``for` `i ``in` `range``(M):` `        ``for` `j ``in` `range``(N):`   `            ``# Increment columns[i]` `            ``if` `(a[j][i] ``=``=` `1``):` `                ``columns[i] ``+``=` `1`   `    ``# Stores the count of triangles` `    ``answer ``=` `0`   `    ``for` `i ``in` `range``(N):` `        ``for` `j ``in` `range``(M):`   `            ``# If current cell has value 1` `            ``if` `(a[i][j] ``=``=` `1``):`   `                ``# Update the answer` `                ``answer ``+``=` `((rows[i] ``-` `1``) ``*` `                      ``(columns[j] ``-` `1``))`   `    ``# Return the count` `    ``return` `answer`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given grid arr` `    ``arr ``=` `[ [ ``1``, ``0``, ``1``, ``0` `],` `            ``[ ``0``, ``1``, ``1``, ``1` `],` `            ``[ ``1``, ``0``, ``1``, ``0` `],` `            ``[ ``0``, ``1``, ``0``, ``1` `] ]`   `    ``# Function call` `    ``print``(numberOfTriangle(arr))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the` `// above approach` `using` `System;`   `class` `GFG{`   `// Function to count the right-angled` `// traingle in the given grid[,]a` `static` `int` `numberOfTriangle(``int``[,] a)` `{` `  ``int` `N = a.GetLength(0);` `  ``int` `M = a.GetLength(1);`   `  ``// Stores the count of 1s for` `  ``// each []row and column[]` `  ``int` `[]rows = ``new` `int``[N];` `  ``int` `[]columns = ``new` `int``[M];`   `  ``// Find the number of 1s in` `  ``// each of the rows[0, N - 1]` `  ``for``(``int` `i = 0; i < N; ++i) ` `  ``{` `    ``for``(``int` `j = 0; j < M; ++j) ` `    ``{` `      `  `      ``// Increment row[i]` `      ``if` `(a[i, j] == 1) ` `      ``{` `        ``rows[i]++;` `      ``}` `    ``}` `  ``}`   `  ``// Find the number of 1s in` `  ``// each of the columns[0, N - 1]` `  ``for``(``int` `i = 0; i < M; ++i) ` `  ``{` `    ``for``(``int` `j = 0; j < N; ++j) ` `    ``{` `      `  `      ``// Increment columns[i]` `      ``if` `(a[j, i] == 1) ` `      ``{` `        ``columns[i]++;` `      ``}` `    ``}` `  ``}`   `  ``// Stores the count ` `  ``// of triangles` `  ``int` `answer = 0;`   `  ``for``(``int` `i = 0; i < N; i++) ` `  ``{` `    ``for``(``int` `j = 0; j < M; ++j) ` `    ``{` `      `  `      ``// If current cell ` `      ``// has value 1` `      ``if` `(a[i, j] == 1) ` `      ``{` `        `  `        ``// Update the answer` `        ``answer += (rows[i] - 1) * ` `               ``(columns[j] - 1);` `      ``}` `    ``}` `  ``}`   `  ``// Return the count` `  ``return` `answer;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  `  `  ``// Given grid [,]arr` `  ``int` `[,]arr = { { 1, 0, 1, 0 },` `                 ``{ 0, 1, 1, 1 },` `                 ``{ 1, 0, 1, 0 },` `                 ``{ 0, 1, 0, 1 } };`   `  ``// Function Call` `  ``Console.Write(numberOfTriangle(arr));` `}` `}`   `// This code is contributed by Amit Katiyar`

Output

```16

```

Time Complexity: O(N*M) where NxM is the dimensions of the given grid.
Space Complexity: O(N*M)

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.