Wildlife Bridge Network Scan

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();
    }
}

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;
}

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);
}

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)

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
}

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;
}