Reachable Nodes With Restrictions - Practice Coding Problems

Reachable Nodes With Restrictions - Problem

Array Hash Table Tree Depth-First Search Breadth-First Search Union Find Graph Medium

Imagine you're exploring a connected network of locations, but some areas are off-limits! You have an undirected tree with n nodes labeled from 0 to n - 1, connected by exactly n - 1 edges.

You're given:

A 2D array edges where edges[i] = [a_i, b_i] represents a connection between nodes a_i and b_i
An array restricted containing nodes you cannot visit

Goal: Starting from node 0 (which is never restricted), find the maximum number of nodes you can reach without passing through any restricted nodes.

Think of it as exploring a city where certain intersections are blocked - you want to see how much of the city you can still explore!

Input & Output

example_1.py — Basic Tree

$ Input: n = 7, edges = [[0,1],[1,2],[3,1],[4,0],[0,5],[5,6]], restricted = [4,5]

› Output: 4

💡 Note: Starting from node 0, we can reach nodes 1, 2, and 3. We cannot reach nodes 4, 5, or 6 because nodes 4 and 5 are restricted, blocking the path to node 6.

example_2.py — Single Restriction

$ Input: n = 4, edges = [[0,1],[1,2],[2,3]], restricted = [2]

› Output: 2

💡 Note: From node 0, we can only reach node 1. Node 2 is restricted, which also blocks access to node 3.

example_3.py — No Restrictions

$ Input: n = 5, edges = [[0,1],[0,2],[1,3],[1,4]], restricted = []

› Output: 5

💡 Note: With no restrictions, we can reach all nodes from node 0. The tree is fully traversable.

Constraints

2 ≤ n ≤ 10⁵
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
edges represents a valid tree
1 ≤ restricted.length < n
0 ≤ restricted[i] < n
All the values of restricted are unique
restricted does not contain 0

Visualization

Tap to expand

Understanding the Visualization

Mark Blocked Areas

Convert restricted nodes array to hash set for instant lookup

Start Exploration

Begin DFS from node 0 (the depot/starting point)

Check Before Moving

For each neighbor, check if it's blocked using O(1) hash lookup

Count Reachable

Accumulate count of all nodes visited during the traversal

Key Takeaway

🎯 Key Insight: Use DFS with hash set for O(1) restriction checks - single traversal gives O(n) optimal solution!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses DFS with hash set lookups to traverse the tree once from node 0. Key insights: convert restrictions to a hash set for O(1) checks, leverage the tree property that each node has exactly one path from the root, and count all visited non-restricted nodes in a single traversal for O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Graph Traversal)	O(n²)	O(n)	For each node, check if reachable from node 0 using separate DFS/BFS
DFS/BFS with Hash Set (Optimal)	O(n)	O(n)	Single traversal from node 0 using hash set for O(1) restriction checks

Brute Force (Nested Graph Traversal) — Algorithm Steps

Build adjacency list from edges
For each node from 1 to n-1, perform DFS/BFS from node 0
During each traversal, skip restricted nodes
Count how many nodes are reachable
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Node 1

Perform full DFS from node 0 to see if we can reach node 1

Check Node 2

Perform another full DFS from node 0 to see if we can reach node 2

Repeat for All

Continue this inefficient process for every single node

Code -

solution.c — C

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

#define MAX_N 100000

int graph[MAX_N][MAX_N];
int graph_size[MAX_N];
bool restricted_set[MAX_N];
bool visited[MAX_N];

bool dfs(int node, int target, int n) {
    if (node == target) return true;
    if (restricted_set[node] || visited[node]) return false;
    
    visited[node] = true;
    for (int i = 0; i < graph_size[node]; i++) {
        if (dfs(graph[node][i], target, n)) {
            return true;
        }
    }
    return false;
}

bool canReach(int target, int n) {
    if (restricted_set[target]) return false;
    
    for (int i = 0; i < n; i++) visited[i] = false;
    return dfs(0, target, n);
}

int reachableNodes(int n, int edges[][2], int edges_size, int restricted[], int restricted_size) {
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graph_size[i] = 0;
        restricted_set[i] = false;
    }
    
    // Build adjacency list
    for (int i = 0; i < edges_size; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graph_size[a]++] = b;
        graph[b][graph_size[b]++] = a;
    }
    
    // Mark restricted nodes
    for (int i = 0; i < restricted_size; i++) {
        restricted_set[restricted[i]] = true;
    }
    
    int count = 1;
    for (int i = 1; i < n; i++) {
        if (canReach(i, n)) {
            count++;
        }
    }
    
    return count;
}

int main() {
    printf("C implementation\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire tree of n nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list and recursion stack

⚡ Linearithmic Space

42.7K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 (Nested Graph Traversal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler