Reachable Nodes With Restrictions

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

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

✓ Brute Force (Nested Graph Traversal)

⏱️ Time: O(n²) Space: O(n)

This approach checks each node individually by performing a separate graph traversal from node 0 to see if we can reach it without hitting restricted nodes. Highly inefficient as it repeats work.

DFS/BFS with Hash Set (Optimal)

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

The optimal approach performs a single DFS or BFS traversal starting from node 0, using a hash set to quickly check if a node is restricted. This leverages the tree property that there's exactly one path between any two nodes.

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>
#include <string.h>

#define MAX_NODES 100000

typedef struct Node {
    int vertex;
    struct Node* next;
} Node;

static Node* adj[MAX_NODES];
static bool visited[MAX_NODES];
static bool isRestricted[MAX_NODES];
static int queue[MAX_NODES];
static int edges[MAX_NODES][2];
static int restricted[MAX_NODES];

Node* createNode(int v) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->vertex = v;
    newNode->next = NULL;
    return newNode;
}

void addEdge(int u, int v) {
    Node* newNode = createNode(v);
    newNode->next = adj[u];
    adj[u] = newNode;
    
    newNode = createNode(u);
    newNode->next = adj[v];
    adj[v] = newNode;
}

bool canReach(int n, int target) {
    if (target == 0) return true;
    if (isRestricted[target]) return false;
    
    for (int i = 0; i < n; i++) {
        visited[i] = false;
    }
    
    int front = 0, rear = 0;
    
    queue[rear++] = 0;
    visited[0] = true;
    
    while (front < rear) {
        int curr = queue[front++];
        
        Node* temp = adj[curr];
        while (temp != NULL) {
            int neighbor = temp->vertex;
            
            if (!visited[neighbor] && !isRestricted[neighbor]) {
                if (neighbor == target) {
                    return true;
                }
                visited[neighbor] = true;
                queue[rear++] = neighbor;
            }
            temp = temp->next;
        }
    }
    
    return false;
}

int main() {
    char line[1000000];
    
    // Read n
    fgets(line, sizeof(line), stdin);
    int n = 0;
    for (int i = 0; line[i]; i++) {
        char c = line[i];
        if (c >= '0' && c <= '9') {
            n = n * 10 + (c - '0');
        }
    }
    
    // Read edges
    fgets(line, sizeof(line), stdin);
    
    // Parse edges manually
    int numbers[MAX_NODES];
    int numbersSize = 0;
    int num = -1;
    for (int i = 0; line[i]; i++) {
        char c = line[i];
        if (c >= '0' && c <= '9') {
            if (num == -1) {
                num = 0;
            }
            num = num * 10 + (c - '0');
        } else {
            if (num != -1) {
                numbers[numbersSize++] = num;
                num = -1;
            }
        }
    }
    if (num != -1) {
        numbers[numbersSize++] = num;
    }
    
    // Build adjacency list
    for (int i = 0; i < n; i++) {
        adj[i] = NULL;
    }
    
    for (int i = 0; i < numbersSize; i += 2) {
        int u = numbers[i];
        int v = numbers[i + 1];
        addEdge(u, v);
    }
    
    // Read restricted
    fgets(line, sizeof(line), stdin);
    
    // Parse restricted
    for (int i = 0; i < n; i++) {
        isRestricted[i] = false;
    }
    
    num = -1;
    for (int i = 0; line[i]; i++) {
        char c = line[i];
        if (c >= '0' && c <= '9') {
            if (num == -1) {
                num = 0;
            }
            num = num * 10 + (c - '0');
        } else {
            if (num != -1) {
                isRestricted[num] = true;
                num = -1;
            }
        }
    }
    if (num != -1) {
        isRestricted[num] = true;
    }
    
    // Brute force: For each node from 1 to n-1, perform BFS from node 0
    int count = 1;
    
    for (int node = 1; node < n; node++) {
        if (canReach(n, node)) {
            count++;
        }
    }
    
    // Output
    printf("%d\n", count);
    
    // Free memory
    for (int i = 0; i < n; i++) {
        Node* temp = adj[i];
        while (temp != NULL) {
            Node* toFree = temp;
            temp = temp->next;
            free(toFree);
        }
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

✓ Linear 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