Wildlife Bridge Network Scan

Published at05 Jan 2026

String Easy 6 views

Like8

In Wildlife Bridge Network Scan, you are given a network of numbered points, a starting point, and a list of blocked points. Your task is to count how many points can still be reached from the start while respecting the blocked list.

The input includes n for the number of points, paths for the connections, start for where the scan begins, and closed_bridges for the locations that should not be entered. The result is not the actual set of visited points. It is just the count.

For example, one of the test cases starts from point 0 in a small network and blocks point 2. In that case, the scan can still cover 0 and 1, so the answer is 2. Another test starts from point 4 in a network with no blocked points and reaches four positions total, so the answer is 4.

So the task is to build the network, avoid blocked positions, explore from the start, and return how many points are reachable under those rules.

Example Input & Output

Example 1

Input

n = 5, paths = [[0,1],[1,2],[2,0],[3,4]], start = 0, closed_bridges = [2]

Output

Explanation

Point 2 is blocked, so the scan reaches only 0 and 1 in that component.

Example 2

Input

n = 7, paths = [[0,1],[1,2],[2,0],[3,4],[4,5],[5,6]], start = 4, closed_bridges = []

Output

Explanation

With no blocked points, the scan covers the whole connected component containing 4.

Example 3

Input

n = 1, paths = [], start = 0, closed_bridges = []

Output

Explanation

A single open node is reachable from itself, so the count is 1.

Algorithm Flow

Recommendation Algorithm Flow for Wildlife Bridge Network Scan

Solution Approach

A good way to solve this problem is to treat the input as a graph reachability task and run a normal graph traversal from the start node. The two standard options are depth-first search (DFS) or breadth-first search (BFS). Either one works because the problem only asks for how many nodes are reachable, not for a shortest path.

The first step is to build an adjacency list from the paths input. That gives you a quick way to find every neighbor of a node during traversal. After that, place the blocked points into a set so you can test membership in constant time. If the start node itself is blocked, then the reachable count should be 0 or 1 depending on the exact export rule, but the shown tests all keep the start usable, so the main traversal logic is still straightforward.

In JavaScript, the structure can look like this:

const graph = Array.from({ length: n }, () => []);
for (const [a, b] of paths) {
  graph[a].push(b);
  graph[b].push(a);
}

const blocked = new Set(closedBridges);
const seen = new Set();
const stack = [start];

while (stack.length > 0) {
  const node = stack.pop();
  if (seen.has(node) || blocked.has(node)) continue;
  seen.add(node);
  for (const next of graph[node]) {
    if (!seen.has(next) && !blocked.has(next)) {
      stack.push(next);
    }
  }
}

return seen.size;

This uses DFS with an explicit stack, but a queue-based BFS would be just as valid. The important parts are: never revisit a node already seen, never enter a blocked node, and keep expanding through the graph until no more legal moves remain.

This matches the intent of the tests and examples. When no points are blocked, the traversal covers the whole connected component of the start node. When some points are blocked, they cut off part of the network and reduce the reachable count.

The time complexity is O(n + m), where m is the number of paths, because each node and edge is processed at most a constant number of times. The extra space is also O(n + m) for the graph, visited set, and traversal structure.

So the full strategy is: build the graph, store blocked nodes in a set, traverse from the start while skipping blocked and already seen nodes, and return the number of visited nodes.

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

java

import java.util.*;

class Solution {
    public int wildlife_bridge_reach(int n, int[][] paths, int start, int[] closed_bridges) {
        List<List<Integer>> adj = new ArrayList<>();
        for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
        
        Set<Integer> closed = new HashSet<>();
        for (int b : closed_bridges) closed.add(b);
        
        for (int[] path : paths) {
            if (path[0] < n && path[1] < n) {
                adj.get(path[0]).add(path[1]);
                adj.get(path[1]).add(path[0]);
            }
        }
        
        if (closed.contains(start)) return 0;
        
        Set<Integer> visited = new HashSet<>();
        Queue<Integer> queue = new LinkedList<>();
        
        visited.add(start);
        queue.add(start);
        
        while (!queue.isEmpty()) {
            int curr = queue.poll();
            for (int neighbor : adj.get(curr)) {
                if (!visited.contains(neighbor) && !closed.contains(neighbor)) {
                    visited.add(neighbor);
                    queue.add(neighbor);
                }
            }
        }
        
        return visited.size();
    }
}

javascript

function wildlife_bridge_reach(n, paths, start, closed_bridges) {
    const adj = Array.from({ length: n }, () => []);
    const closed = new Set(closed_bridges);
    for (const [u, v] of paths) {
        if (u < n && v < n) {
            adj[u].push(v);
            adj[v].push(u);
        }
    }
    
    if (closed.has(start)) return 0;
    
    const visited = new Set([start]);
    const queue = [start];
    
    while (queue.length > 0) {
        const curr = queue.shift();
        for (const neighbor of adj[curr]) {
            if (!visited.has(neighbor) && !closed.has(neighbor)) {
                visited.add(neighbor);
                queue.push(neighbor);
            }
        }
    }
    return visited.size;
}

php

function wildlife_bridge_reach($n, $paths, $start, $closed_bridges) {
    $adj = array_fill(0, $n, []);
    $closed = array_flip($closed_bridges);
    
    foreach ($paths as $path) {
        $u = $path[0];
        $v = $path[1];
        if ($u < $n && $v < $n) {
            $adj[$u][] = $v;
            $adj[$v][] = $u;
        }
    }
    
    if (isset($closed[$start])) return 0;
    
    $visited = [$start => true];
    $queue = [$start];
    
    while (count($queue) > 0) {
        $curr = array_shift($queue);
        foreach ($adj[$curr] as $neighbor) {
            if (!isset($visited[$neighbor]) && !isset($closed[$neighbor])) {
                $visited[$neighbor] = true;
                $queue[] = $neighbor;
            }
        }
    }
    
    return count($visited);
}

python

from typing import List

def wildlife_bridge_reach(n: int, paths: List[List[int]], start: int, closed_bridges: List[int]) -> int:
    adj = {i: [] for i in range(n)}
    closed = set(closed_bridges)
    for u, v in paths:
        if u < n:
            adj[u].append(v)
        if v < n:
            adj[v].append(u)
    
    if start in closed:
        return 0
    
    visited = {start}
    queue = [start]
    
    while queue:
        curr = queue.pop(0)
        for neighbor in adj.get(curr, []):
            if neighbor not in visited and neighbor not in closed:
                visited.add(neighbor)
                queue.append(neighbor)
    
    return len(visited)

rust

use std::collections::{HashSet, VecDeque};

pub fn wildlife_bridge_reach(n: i32, paths: Vec<Vec<i32>>, start: i32, closed_bridges: Vec<i32>) -> i32 {
    let mut adj = vec![vec![]; n as usize];
    let closed: HashSet<i32> = closed_bridges.into_iter().collect();
    
    for path in paths {
        let u = path[0] as usize;
        let v = path[1] as usize;
        if u < n as usize && v < n as usize {
            adj[u].push(v as i32);
            adj[v].push(u as i32);
        }
    }
    
    if closed.contains(&start) { return 0; }
    
    let mut visited = HashSet::new();
    let mut queue = VecDeque::new();
    
    visited.insert(start);
    queue.push_back(start);
    
    while let Some(curr) = queue.pop_front() {
        for &neighbor in &adj[curr as usize] {
            if !visited.contains(&neighbor) && !closed.contains(&neighbor) {
                visited.insert(neighbor);
                queue.push_back(neighbor);
            }
        }
    }
    
    visited.len() as i32
}

typescript

function wildlife_bridge_reach(n: number, paths: number[][], start: number, closed_bridges: number[]): number {
    var adj: number[][] = [];
    for (var i = 0; i < n; i++) adj.push([]);
    
    var closed: { [key: number]: boolean } = {};
    for (var i = 0; i < closed_bridges.length; i++) {
        closed[closed_bridges[i]] = true;
    }
    
    for (var i = 0; i < paths.length; i++) {
        var u = paths[i][0];
        var v = paths[i][1];
        if (u < n && v < n) {
            adj[u].push(v);
            adj[v].push(u);
        }
    }
    
    if (closed[start]) return 0;
    
    var visited: { [key: number]: boolean } = {};
    visited[start] = true;
    var queue = [start];
    var head = 0;
    
    while (head < queue.length) {
        var curr = queue[head++];
        var neighbors = adj[curr];
        for (var i = 0; i < neighbors.length; i++) {
            var neighbor = neighbors[i];
            if (!visited[neighbor] && !closed[neighbor]) {
                visited[neighbor] = true;
                queue.push(neighbor);
            }
        }
    }
    return queue.length;
}

Related String Challenges

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this Challenge.

Wildlife Bridge Network Scan

Example Input & Output

Algorithm Flow

Solution Approach

Best AnswersThese are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

Solutions Coming Soon

Related String Challenges

Equinox Gate Verdict

Reverse String

Check Palindrome

Vowel Counter

String Length

Mountain Cabin Signal Range

Comments (0)

Join the Discussion

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.