Harbor Ferry Route Planner

Published atDate not available

Array Easy 0 views

Like0

Think of a small harbor challenge where order and timing really matter. In Harbor Ferry Route Planner, you are trying to work toward the right number by following one clear idea.

This problem feels a bit like a maze or map challenge. You need to think about how moves, paths, or links work together. Some places may still connect nicely, while others may be blocked or no longer fit the rule. The answer comes from following those connections carefully.

For example, if the input is n = 4, routes = [[0,1],[1,2],[2,3]], origin = 3, max_transfers = 0, the answer is 1. With no transfers allowed, only the starting dock receives the announcement. Another example is n = 5, routes = [[0,1],[1,2],[2,0],[3,4]], origin = 1, max_transfers = 1, which gives 3. Docks 0, 1, and 2 form a reachable group within one transfer of the origin.

This is a friendly practice problem, but it still rewards careful reading. The key is keeping track of where you can move and which routes still follow the rule.

Example Input & Output

Example 1

Input

n = 4, routes = [[0,1],[1,2],[2,3]], origin = 3, max_transfers = 0

Output

Explanation

With no transfers allowed, only the starting dock receives the announcement.

Example 2

Input

n = 5, routes = [[0,1],[1,2],[2,0],[3,4]], origin = 1, max_transfers = 1

Output

Explanation

Docks 0, 1, and 2 form a reachable group within one transfer of the origin.

Example 3

Input

n = 6, routes = [[0,1],[1,2],[2,3],[3,4],[4,5]], origin = 0, max_transfers = 3

Output

Explanation

The crew may visit docks 0, 1, 2, and 3 before exceeding the transfer cap.

Algorithm Flow

Recommendation Algorithm Flow for Harbor Ferry Route Planner

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_route_reach(int n, int[][] routes, int origin, int max_transfers) {
        Map<Integer, List<Integer>> graph = new HashMap<>();
        for (int i = 0; i < n; i++) graph.put(i, new ArrayList<>());
        for (int[] route : routes) {
            graph.get(route[0]).add(route[1]);
            graph.get(route[1]).add(route[0]);
        }
        
        Set<Integer> visited = new HashSet<>();
        visited.add(origin);
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{origin, 0});
        
        while (!queue.isEmpty()) {
            int[] curr = queue.poll();
            int harbor = curr[0], transfers = curr[1];
            if (transfers < max_transfers) {
                for (int neighbor : graph.get(harbor)) {
                    if (!visited.contains(neighbor)) {
                        visited.add(neighbor);
                        queue.offer(new int[]{neighbor, transfers + 1});
                    }
                }
            }
        }
        
        return visited.size();
    }
}

javascript

function ferry_route_reach(n, routes, origin, max_transfers) {
    const graph = {};
    for (let i = 0; i < n; i++) graph[i] = [];
    for (const [u, v] of routes) {
        graph[u].push(v);
        graph[v].push(u);
    }
    
    const visited = new Set([origin]);
    const queue = [[origin, 0]];
    
    while (queue.length > 0) {
        const [harbor, transfers] = queue.shift();
        if (transfers < max_transfers) {
            for (const neighbor of graph[harbor]) {
                if (!visited.has(neighbor)) {
                    visited.add(neighbor);
                    queue.push([neighbor, transfers + 1]);
                }
            }
        }
    }
    
    return visited.size;
}

php

<?php
function ferry_route_reach($n, $routes, $origin, $max_transfers) {
    $graph = [];
    for ($i = 0; $i < $n; $i++) $graph[$i] = [];
    foreach ($routes as $route) {
        $graph[$route[0]][] = $route[1];
        $graph[$route[1]][] = $route[0];
    }
    
    $visited = [$origin => true];
    $queue = [[$origin, 0]];
    
    while (count($queue) > 0) {
        list($harbor, $transfers) = array_shift($queue);
        if ($transfers < $max_transfers) {
            foreach ($graph[$harbor] as $neighbor) {
                if (!isset($visited[$neighbor])) {
                    $visited[$neighbor] = true;
                    $queue[] = [$neighbor, $transfers + 1];
                }
            }
        }
    }
    
    return count($visited);
}
?>

python

from typing import List
from collections import deque

def ferry_route_reach(n: int, routes: List[List[int]], origin: int, max_transfers: int) -> int:
    graph = {i: [] for i in range(n)}
    for u, v in routes:
        graph[u].append(v)
        graph[v].append(u)
    
    visited = set([origin])
    queue = deque([(origin, 0)])
    
    while queue:
        harbor, transfers = queue.popleft()
        if transfers < max_transfers:
            for neighbor in graph[harbor]:
                if neighbor not in visited:
                    visited.add(neighbor)
                    queue.append((neighbor, transfers + 1))
    
    return len(visited)

rust

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

pub fn ferry_route_reach(n: i32, routes: Vec<(i32, i32)>, origin: i32, max_transfers: i32) -> i32 {
    let mut graph: HashMap<i32, Vec<i32>> = HashMap::new();
    for i in 0..n {
        graph.insert(i, Vec::new());
    }
    for (u, v) in routes {
        graph.get_mut(&u).unwrap().push(v);
        graph.get_mut(&v).unwrap().push(u);
    }
    
    let mut visited = HashSet::new();
    visited.insert(origin);
    let mut queue = VecDeque::new();
    queue.push_back((origin, 0));
    
    while let Some((harbor, transfers)) = queue.pop_front() {
        if transfers < max_transfers {
            if let Some(neighbors) = graph.get(&harbor) {
                for &neighbor in neighbors {
                    if !visited.contains(&neighbor) {
                        visited.insert(neighbor);
                        queue.push_back((neighbor, transfers + 1));
                    }
                }
            }
        }
    }
    
    visited.len() as i32
}

typescript

function ferry_route_reach(n: number, routes: number[][], origin: number, max_transfers: number): number {
    const graph: { [key: number]: number[] } = {};
    for (let i = 0; i < n; i++) graph[i] = [];
    for (const [u, v] of routes) {
        graph[u].push(v);
        graph[v].push(u);
    }
    
    const visited = new Set<number>([origin]);
    const queue: [number, number][] = [[origin, 0]];
    
    while (queue.length > 0) {
        const item = queue.shift();
        if (!item) break;
        const [harbor, transfers] = item;
        if (transfers < max_transfers) {
            for (const neighbor of graph[harbor]) {
                if (!visited.has(neighbor)) {
                    visited.add(neighbor);
                    queue.push([neighbor, transfers + 1]);
                }
            }
        }
    }
    
    return visited.size;
}

Related Array Challenges

Comments (0)

Join the Discussion

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

Harbor Ferry Route Planner

Example Input & Output

Algorithm Flow

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

Skyway Signal Cluster

Museum Corridor Sweep

City Signal Span

Celestial Skyline Layout

Aurora Diary Synthesis

Ember Glyph Mosaic

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.