Seaport Ferry Gate Control

Published at05 Jan 2026

Graph BFS Easy 21 views

Like7

This challenge becomes much easier once you know exactly what to keep, change, or count. In Seaport Ferry Gate Control, you are trying to work toward the right number by following one clear idea.

Control seaport ferry gate timing A good way to think about it is to first understand what goes in, then what rule you must follow, and finally what shape the answer should have.

For example, if the input is n = 5, routes = [[0,2],[2,4],[1,2],[3,4],[0,1]], start = 4, closed_gates = [1], the answer is 3. Starting at gate 4 allows access to gates 2 and 3 even though gate 1 is closed. Another example is n = 4, routes = [[0,1],[1,2]], start = 3, closed_gates = [], which gives 1. Gate 3 has no connecting routes, so only the origin counts toward the total.

This is a friendly practice problem, but it still rewards careful reading. The key is understanding the rule clearly and then applying it carefully.

Example Input & Output

Example 1

Input

n = 5, routes = [[0,2],[2,4],[1,2],[3,4],[0,1]], start = 4, closed_gates = [1]

Output

Explanation

Starting at gate 4 allows access to gates 2 and 3 even though gate 1 is closed.

Example 2

Input

n = 4, routes = [[0,1],[1,2]], start = 3, closed_gates = []

Output

Explanation

Gate 3 has no connecting routes, so only the origin counts toward the total.

Example 3

Input

n = 6, routes = [[0,1],[1,2],[2,3],[3,4],[4,5]], start = 1, closed_gates = [3]

Output

Explanation

Gates 1, 0, and 2 stay connected, while gates beyond the closed gate 3 are unreachable.

Algorithm Flow

Recommendation Algorithm Flow for Seaport Ferry Gate Control

Solution Approach

This problem asks us to count how many gates the ferry can reach from a starting gate, skipping any closed gates. The routes form an undirected graph, and we must build the graph without any edge that touches a closed gate, then count the connected component of the start.

The key detail is handling the case where the start itself is closed: in that situation no travel is possible, so the answer is 0. Otherwise we build the graph with only open gates and run a standard BFS.

Here is the implementation:

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

We put the closed gates in a set and immediately return 0 if the start is closed. While building the graph, we only add an edge when neither endpoint is closed, which removes closed gates and their routes. Then BFS from the start counts the reachable component.

Let us trace n = 5, routes = [[0,2],[2,4],[1,2],[3,4],[0,1]], start = 4, closed_gates = [1]. Gate 1 is closed, so routes touching it are dropped, leaving edges [0,2], [2,4], and [3,4]. From gate 4 we reach 2, 0, and 3, giving 3. When the start is isolated with no routes, only the origin is counted, giving 1.

The time complexity is O(n + e) and the space complexity is O(n).

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

javascript

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

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

python

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)

rust

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
}

typescript

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

Related Graph Challenges

Comments (0)

Join the Discussion

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

Seaport Ferry Gate Control

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 Graph Challenges

City Bus Loop Access

Railway Network Delay Optimizer

Interstate Rescue Network Audit

Wildlife Bridge Network Scan

Metro Transfer Capacity Map

City Signal Span

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.