Paths in Maze That Lead to Same Room - Practice Coding Problems

Paths in Maze That Lead to Same Room - Problem

Graph Medium

The Maze Confusion Challenge

You're tasked with analyzing a mysterious maze to determine just how confusing it is! The maze consists of n rooms numbered from 1 to n, connected by bidirectional corridors.

The confusion score of the maze is defined as the number of different triangular cycles (cycles of exactly length 3) present in the maze. Think of it this way: if you can start from a room, visit exactly two other rooms, and return to your starting point, you've found a confusing triangle!

For example, the path 1 → 2 → 3 → 1 forms a triangle and contributes to the confusion score. However, longer paths like 1 → 2 → 3 → 4 or paths that backtrack like 1 → 2 → 3 → 2 → 1 don't count.

Your Goal: Given the corridor connections, calculate how many unique triangular cycles exist in the maze.

Input & Output

example_1.py — Basic Triangle

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

› Output: 0

💡 Note: This forms a square (cycle of length 4) but no triangles. To have a triangle, we'd need a diagonal connection like [1,3] or [2,4].

example_2.py — Single Triangle

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

› Output: 1

💡 Note: Rooms 1, 2, and 3 form exactly one triangle: 1→2→3→1. Rooms 4 and 5 are connected to the triangle but don't form additional triangles.

example_3.py — Multiple Triangles

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

› Output: 4

💡 Note: This is a complete graph with 4 nodes. Every combination of 3 nodes forms a triangle: (1,2,3), (1,2,4), (1,3,4), (2,3,4).

Visualization

Tap to expand

Understanding the Visualization

Map the Network

Build adjacency lists showing each person's friends

Pick a Friendship

Select any friendship (edge) between two people

Find Mutual Friends

Identify people who are friends with both endpoints

Count Triangles

Each mutual friend creates exactly one triangle with the original pair

Key Takeaway

🎯 Key Insight: Instead of checking all possible triangles (O(n³)), we examine each edge and count its common neighbors (O(m√m)). This transforms a cubic problem into a much more efficient graph traversal!

Time & Space Complexity

Time Complexity

⏱️

O(m * √m)

For each edge, we find common neighbors. In sparse graphs, this is much better than O(n³)

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency lists where m is number of edges

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
0 ≤ corridors.length ≤ 5 * 10⁴
corridors[i].length == 2
1 ≤ room1_i, room2_i ≤ n
room1_i ≠ room2_i
No duplicate corridors will be given
The corridors are undirected (bidirectional)

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 21

The optimal approach uses edge-based triangle detection: for each corridor, find rooms that are connected to both endpoints. This directly counts triangles without duplicates and achieves O(m√m) time complexity, much better than brute force O(n³) for sparse graphs.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Edge-Based Detection	O(m * √m)	O(n + m)	For each edge, count common neighbors of its endpoints
Adjacency List + Triangle Detection	O(n * d²)	O(n + m)	Build adjacency lists first, then check triangles by examining neighbors
Brute Force (Check All Triangles)	O(n³)	O(n²)	Check every possible combination of 3 nodes to see if they form a triangle

Optimized Edge-Based Detection — Algorithm Steps

Build adjacency lists for all rooms
For each edge (u, v) in the corridors list
Find intersection of neighbors of u and neighbors of v
Each common neighbor w forms triangle (u, v, w)

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Edge

Pick an edge (u,v) from corridors

Get Neighbors

Find neighbors of both u and v

Find Intersection

Common neighbors form triangles with edge (u,v)

Count Triangles

Add number of common neighbors to total

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_EDGES 10000

int adj[MAX_N + 1][MAX_N + 1];
int degree[MAX_N + 1];
int neighbors[MAX_N + 1][MAX_N];
char processedEdges[MAX_EDGES][20];
int processedCount = 0;

int isProcessed(int r1, int r2) {
    char edge[20];
    if (r1 < r2) {
        sprintf(edge, "%d,%d", r1, r2);
    } else {
        sprintf(edge, "%d,%d", r2, r1);
    }
    
    for (int i = 0; i < processedCount; i++) {
        if (strcmp(processedEdges[i], edge) == 0) {
            return 1;
        }
    }
    
    strcpy(processedEdges[processedCount], edge);
    processedCount++;
    return 0;
}

int numberOfPaths(int n, int** corridors, int corridorsSize, int* corridorsColSize) {
    // Initialize
    memset(adj, 0, sizeof(adj));
    memset(degree, 0, sizeof(degree));
    processedCount = 0;
    
    // Build adjacency lists
    for (int i = 0; i < corridorsSize; i++) {
        int room1 = corridors[i][0], room2 = corridors[i][1];
        adj[room1][room2] = adj[room2][room1] = 1;
        neighbors[room1][degree[room1]++] = room2;
        neighbors[room2][degree[room2]++] = room1;
    }
    
    int count = 0;
    
    // For each corridor, find common neighbors
    for (int i = 0; i < corridorsSize; i++) {
        int room1 = corridors[i][0], room2 = corridors[i][1];
        
        // Skip if already processed
        if (isProcessed(room1, room2)) {
            continue;
        }
        
        // Find common neighbors
        for (int j = 0; j < degree[room1]; j++) {
            int neighbor = neighbors[room1][j];
            if (adj[room2][neighbor]) {
                count++;
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * √m)

For each edge, we find common neighbors. In sparse graphs, this is much better than O(n³)

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency lists where m is number of edges

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 1000
0 ≤ corridors.length ≤ 5 * 10⁴
corridors[i].length == 2
1 ≤ room1_i, room2_i ≤ n
room1_i ≠ room2_i
No duplicate corridors will be given
The corridors are undirected (bidirectional)

31.5K Views

Medium Frequency

~25 min Avg. Time

842 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Edge-Based Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler