Paths in Maze That Lead to Same Room

Paths in Maze That Lead to Same Room - Problem

Graph Medium

A maze consists of n rooms numbered from 1 to n, and some rooms are connected by corridors. You are given a 2D integer array corridors where corridors[i] = [room1i, room2i] indicates that there is a corridor connecting room1i and room2i, allowing a person in the maze to go from room1i to room2i and vice versa.

The designer of the maze wants to know how confusing the maze is. The confusion score of the maze is the number of different cycles of length 3.

For example, 1 → 2 → 3 → 1 is a cycle of length 3, but 1 → 2 → 3 → 4 and 1 → 2 → 3 → 2 → 1 are not.

Two cycles are considered to be different if one or more of the rooms visited in the first cycle is not in the second cycle.

Return the confusion score of the maze.

Input & Output

Example 1 — Basic Triangle

$ Input: n = 5, corridors = [[1,2],[2,3],[3,1]]

› Output: 1

💡 Note: There is exactly one cycle of length 3: 1 → 2 → 3 → 1. Rooms 4 and 5 are isolated and don't form any cycles.

Example 2 — Multiple Triangles

$ Input: n = 4, corridors = [[1,2],[2,3],[3,4],[4,1],[1,3]]

› Output: 2

💡 Note: There are exactly two cycles of length 3: 1 → 2 → 3 → 1 and 1 → 3 → 4 → 1. The corridor [1,3] participates in both triangles.

Example 3 — No Triangles

$ Input: n = 4, corridors = [[1,2],[2,3],[3,4]]

› Output: 0

💡 Note: This forms a simple path 1-2-3-4 with no cycles of length 3. All paths are longer than 3 or are not cycles.

Constraints

3 ≤ n ≤ 1000
0 ≤ corridors.length ≤ n × (n-1) / 2
corridors[i].length == 2
1 ≤ room1_i, room2_i ≤ n
room1_i ≠ room2_i
There are no duplicate corridors

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 M Microsoft 8

Find cycles of length 3 (triangles) in an undirected graph. The key insight is that a triangle exists when three rooms are all mutually connected. The adjacency list approach is optimal: for each room, check if pairs of its neighbors are connected to each other. Time: O(E × d), Space: O(E) where E is edges and d is max degree.

Common Approaches

✓ Adjacency List Optimization

⏱️ Time: O(E × d) Space: O(E)

Build adjacency lists for each room, then for each room iterate through pairs of its neighbors to see if those neighbors are also connected to each other, forming a triangle.

Brute Force - Check All Triplets

⏱️ Time: O(n³) Space: O(E)

Generate all possible triplets of rooms and check if each triplet has all three edges connecting them. This requires checking if room A connects to B, B connects to C, and C connects to A.

Adjacency List Optimization — Algorithm Steps

Step 1: Build adjacency list for each room
Step 2: For each room, examine all pairs of its neighbors
Step 3: Check if each neighbor pair is connected to form triangle
Step 4: Count triangles, being careful not to count duplicates

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list for fast neighbor lookup

Check Pairs

For each room, examine pairs of its neighbors

Find Triangle

If neighbor pair connects, we found a triangle

Code -

solution.c — C

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

static int adj[1001][1001];
static int adj_count[1001];

int solution(int n, int corridors[][2], int corridor_count) {
    // Initialize adjacency lists
    for (int i = 1; i <= n; i++) {
        adj_count[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < corridor_count; i++) {
        int u = corridors[i][0];
        int v = corridors[i][1];
        adj[u][adj_count[u]++] = v;
        adj[v][adj_count[v]++] = u;
    }
    
    int count = 0;
    // For each room, check pairs of neighbors
    for (int room = 1; room <= n; room++) {
        // Check all pairs of neighbors
        for (int i = 0; i < adj_count[room]; i++) {
            for (int j = i + 1; j < adj_count[room]; j++) {
                int neighbor1 = adj[room][i];
                int neighbor2 = adj[room][j];
                // Check if the two neighbors are connected
                int connected = 0;
                for (int k = 0; k < adj_count[neighbor1]; k++) {
                    if (adj[neighbor1][k] == neighbor2) {
                        connected = 1;
                        break;
                    }
                }
                // If the two neighbors are connected, we have a triangle
                if (connected) {
                    // Only count triangle if current room has smallest ID
                    int min_neighbor = neighbor1 < neighbor2 ? neighbor1 : neighbor2;
                    if (room < min_neighbor) {
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    
    // Read n
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    // Read corridors array
    fgets(line, sizeof(line), stdin);
    
    // Handle empty array case
    if (strstr(line, "[]") != NULL) {
        printf("0\n");
        return 0;
    }
    
    // Parse the 2D array
    int corridors[5000][2];
    int corridor_count = 0;
    
    char *ptr = line;
    
    // Find each inner array [x,y]
    while (*ptr != '\0') {
        if (*ptr == '[') {
            // Check if this is start of an inner array (next char should be digit)
            char *next = ptr + 1;
            while (*next == ' ') next++; // skip whitespace
            
            if (isdigit(*next)) {
                // Found start of inner array
                ptr = next;
                
                // Parse first number
                char *endptr;
                int first = strtol(ptr, &endptr, 10);
                ptr = endptr;
                
                // Skip comma and whitespace
                while (*ptr == ',' || *ptr == ' ') ptr++;
                
                // Parse second number
                int second = strtol(ptr, &endptr, 10);
                ptr = endptr;
                
                corridors[corridor_count][0] = first;
                corridors[corridor_count][1] = second;
                corridor_count++;
                
                // Skip to next potential '['
                while (*ptr != '[' && *ptr != '\0') ptr++;
            } else {
                ptr++;
            }
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(n, corridors, corridor_count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E × d)

For each edge E, check degree d neighbors in worst case

⚠ Quadratic Growth

Space Complexity

O(E)

Adjacency list storage for all edges

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Adjacency List Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler