Seaport Ferry Gate Control

import java.util.*;

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

function ferry_gate_control(n, routes, start, closed_gates) {
    const closed = new Set(closed_gates);
    if (closed.has(start)) return 0;
    const adj = Array.from({length: n}, () => []);
    for (const [u, v] of routes) {
        if (!closed.has(u) && !closed.has(v)) {
            adj[u].push(v);
            adj[v].push(u);
        }
    }
    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)) {
                visited.add(neighbor);
                queue.push(neighbor);
            }
        }
    }
    return visited.size;
}

<?php
function ferry_gate_control($n, $routes, $start, $closed_gates) {
    if (in_array($start, $closed_gates)) return 0;
    $adj = array_fill(0, $n, []);
    foreach ($routes as $route) {
        $u = $route[0]; $v = $route[1];
        if (!in_array($u, $closed_gates) && !in_array($v, $closed_gates)) {
            $adj[$u][] = $v;
            $adj[$v][] = $u;
        }
    }
    $visited = [$start => true];
    $queue = [$start];
    while (!empty($queue)) {
        $curr = array_shift($queue);
        foreach ($adj[$curr] as $neighbor) {
            if (!isset($visited[$neighbor])) {
                $visited[$neighbor] = true;
                $queue[] = $neighbor;
            }
        }
    }
    return count($visited);
}
?>

from typing import List
from collections import deque

def ferry_gate_control(n: int, routes: List[List[int]], start: int, closed_gates: List[int]) -> int:
    closed = set(closed_gates)
    if start in closed:
        return 0
    adj = [[] for _ in range(n)]
    for u, v in routes:
        if u not in closed and v not in closed:
            adj[u].append(v)
            adj[v].append(u)
    visited = {start}
    queue = deque([start])
    while queue:
        curr = queue.popleft()
        for neighbor in adj[curr]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    return len(visited)

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

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

function ferry_gate_control(n: number, routes: number[][], start: number, closed_gates: number[]): number {
    const closed = new Set(closed_gates);
    if (closed.has(start)) return 0;
    const adj: number[][] = Array.from({length: n}, () => []);
    for (const [u, v] of routes) {
        if (!closed.has(u) && !closed.has(v)) {
            adj[u].push(v);
            adj[v].push(u);
        }
    }
    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)) {
                visited.add(neighbor);
                queue.push(neighbor);
            }
        }
    }
    return visited.size;
}