Seaport Ferry Gate Control

Array Easy 7 views

Like7

The harbor operations team manages a network of ferry gates (0 to n-1). During high tide, some docks are Closed for safety, and vessels cannot pass through or land there. Your mission in Seaport Ferry Gate Control is to count how many unique gates remain accessible from a specific start gate without crossing any closed piers.

The "secret sauce" here is Graph Traversal with Barriers. Use BFS or DFS to explore every route from the origin, but immediately skip any path that enters a closed gate. If the starting gate itself is closed, the answer is zero. This simple traversal helps dispatchers adjust staffing based on which parts of the bay are currently connected. It’s a practical connectivity problem that teaches you how to model and traverse relationships under dynamic constraints. Precision is key to keeping the harbor running safely!

When the task involves connectivity or route cost, build adjacency carefully and guard against revisiting stale states. Use a visited or best-distance structure to avoid repeated work, and ensure unreachable scenarios return the required fallback value instead of partial traversal results.

Examples

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 - Budibadu

Best Answers

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

Comments (0)

Join the Discussion

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

Seaport Ferry Gate Control

Examples

Algorithm Flow

Best Answers

Solutions Coming Soon

Related Array Problems

Longest Consecutive Sequence

Garden Relay Count

Lantern Stall Picks

Festival Stall Order

Studio Lighting Slots

Railway Network Delay Optimizer

Comments (0)

Join the Discussion