Right Triangles

Right Triangles - Problem

You are given a 2D boolean matrix grid. A collection of 3 elements of grid is a right triangle if one of its elements is in the same row with another element and in the same column with the third element.

The 3 elements may not be next to each other. Return an integer that is the number of right triangles that can be made with 3 elements of grid such that all of them have a value of 1.

Input & Output

Example 1 — Basic Grid

$ Input: grid = [[1,0,1],[0,1,1],[0,1,1]]

› Output: 8

💡 Note: There are 8 possible right triangles. For each cell with value 1, we count how many triangles can be formed with that cell as the corner of the L-shape by multiplying the number of other 1s in its row with the number of other 1s in its column.

Example 2 — No Triangles

$ Input: grid = [[1,0,0],[0,1,0],[0,0,1]]

› Output: 0

💡 Note: No three 1s can form a right triangle because no cell shares both a row and column with two other cells containing 1s.

Example 3 — Multiple Triangles

$ Input: grid = [[1,1,1],[1,1,1]]

› Output: 12

💡 Note: With all cells being 1, each cell can form multiple L-shaped triangles. Each corner cell can form triangles by choosing one cell from its row and one from its column, giving (row_count-1) × (col_count-1) triangles per corner.

Constraints

1 ≤ grid.length ≤ 1000
1 ≤ grid[i].length ≤ 1000
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15 M Microsoft 12

The key insight is that for each cell with value 1, the number of right triangles with it as corner equals the product of remaining 1s in its row and column. Best approach is the optimized counting method with precomputed row/column counts. Time: O(m×n), Space: O(m+n)

Common Approaches

✓ Brute Force - Check All Triplets

⏱️ Time: O(n⁶) Space: O(1)

Iterate through all possible triplets of cells with value 1. For each triplet, check if they form a right triangle by verifying that one cell shares a row with another and shares a column with the third.

Optimized - Count Row/Column 1s

⏱️ Time: O(m×n) Space: O(m+n)

For each cell with value 1, count how many other 1s are in the same row and column. The number of triangles with this cell as corner is the product of these counts.

Brute Force - Check All Triplets — Algorithm Steps

Find all cells with value 1
Generate all possible triplets of these cells
For each triplet, check if it forms a right triangle
Count valid triangles

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All 1s

Locate all cells with value 1

Check Triplets

Test each combination of 3 cells

Count Triangles

Count valid L-shaped patterns

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int** grid, int rows, int cols) {
    int count = 0;
    
    // Find all cells with value 1
    int ones[1000][2]; // Assuming max 1000 ones
    int oneCount = 0;
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == 1) {
                ones[oneCount][0] = i;
                ones[oneCount][1] = j;
                oneCount++;
            }
        }
    }
    
    // Check all triplets
    for (int i = 0; i < oneCount; i++) {
        for (int j = i + 1; j < oneCount; j++) {
            for (int k = j + 1; k < oneCount; k++) {
                int r1 = ones[i][0], c1 = ones[i][1];
                int r2 = ones[j][0], c2 = ones[j][1];
                int r3 = ones[k][0], c3 = ones[k][1];
                
                // Check if forms right triangle (L-shape)
                // Point 1 as corner: shares row with point 2, column with point 3
                if (r1 == r2 && c1 == c3 && r1 != r3 && c1 != c2) {
                    count++;
                }
                // Point 1 as corner: shares row with point 3, column with point 2
                else if (r1 == r3 && c1 == c2 && r1 != r2 && c1 != c3) {
                    count++;
                }
                // Point 2 as corner: shares row with point 1, column with point 3
                else if (r2 == r1 && c2 == c3 && r2 != r3 && c2 != c1) {
                    count++;
                }
                // Point 2 as corner: shares row with point 3, column with point 1
                else if (r2 == r3 && c2 == c1 && r2 != r1 && c2 != c3) {
                    count++;
                }
                // Point 3 as corner: shares row with point 1, column with point 2
                else if (r3 == r1 && c3 == c2 && r3 != r2 && c3 != c1) {
                    count++;
                }
                // Point 3 as corner: shares row with point 2, column with point 1
                else if (r3 == r2 && c3 == c1 && r3 != r1 && c3 != c2) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[1,0,1],[0,1,1],[0,1,1]] format
    int grid[100][100];
    int rows = 0, cols = 0;
    
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            cols = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[rows][cols++] = *ptr - '0';
                }
                ptr++;
            }
            rows++;
        }
        ptr++;
    }
    
    // Convert to pointer array
    int* gridPtrs[100];
    for (int i = 0; i < rows; i++) {
        gridPtrs[i] = grid[i];
    }
    
    printf("%d\n", solution(gridPtrs, rows, cols));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁶)

Triple nested loops to check all triplets of cells in an n×n grid

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track positions

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Triplets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler