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

• Difficulty Level : Medium
• Last Updated : 11 Jun, 2021

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``// triangle 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``// triangle 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``# triangle 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``// triangle 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`

## Javascript

 ``
Output
`16`

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

My Personal Notes arrow_drop_up