Harbor Signal Expansion Test

Published at05 Jan 2026

Array Array Manipulation Easy 12 views

Like14

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

Here, you are mostly deciding whether a rule stays true while you look through the input. Sometimes that means checking if things are connected, balanced, or allowed. Sometimes it means noticing the first place where the rule breaks. The answer depends on being careful from beginning to end.

For example, if the input is n = 5, links = [[0,1],[1,2],[2,3],[3,4]], start = 3, maintenance = [], the answer is 5. All towers are online, so the signal covers every lighthouse. Another example is n = 6, links = [[0,1],[1,2],[2,3],[3,4],[4,5]], start = 0, maintenance = [3], which gives 4. Towers 0, 1, 2, and 5 remain online; cable through tower 3 prevents reaching tower 4.

This is a friendly practice problem, but it still rewards careful reading. The key is noticing the exact moment when the rule stays true or breaks.

Example Input & Output

Example 1

Input

n = 5, links = [[0,1],[1,2],[2,3],[3,4]], start = 3, maintenance = []

Output

Explanation

All towers are online, so the signal covers every lighthouse.

Example 2

Input

n = 6, links = [[0,1],[1,2],[2,3],[3,4],[4,5]], start = 0, maintenance = [3]

Output

Explanation

Signal reaches towers 0, 1, and 2 from the start. Tower 3 is offline, which blocks the path to 4 and 5.

Example 3

Input

n = 4, links = [[0,1],[1,2]], start = 2, maintenance = [0,1]

Output

Explanation

Maintenance disables the only connecting cables, so the broadcast stays at the starting lighthouse.

Algorithm Flow

Recommendation Algorithm Flow for Harbor Signal Expansion Test

Solution Approach

This problem asks us to count how many towers the signal can reach from a starting tower while skipping towers under maintenance. The links form an undirected graph, so the answer is the size of the reachable connected component of the start, excluding any maintained towers.

A breadth-first search is the natural approach. We explore outward from the start and simply refuse to visit any tower that is under maintenance, exactly like avoiding a blocked node.

Here is the implementation:

function has_segment_sum(n, links, start, maintenance) {
    const blocked = new Set(maintenance);
    if (blocked.has(start)) return 0;
    const adj = Array.from({ length: n }, () => []);
    for (const [u, v] of links) {
        adj[u].push(v);
        adj[v].push(u);
    }
    const visited = new Set([start]);
    const queue = [start];
    while (queue.length > 0) {
        const u = queue.shift();
        for (const v of adj[u]) {
            if (!visited.has(v) && !blocked.has(v)) {
                visited.add(v);
                queue.push(v);
            }
        }
    }
    return visited.size;
}

First we store the maintained towers in a set and return 0 immediately if the start itself is under maintenance. Then we build an undirected adjacency list from the links, so each link connects both directions.

We seed BFS with the start and expand through neighbors. The key condition is !blocked.has(v): we only visit a neighbor if it is neither already seen nor under maintenance. This prevents the signal from crossing through a maintained tower.

Let us trace n = 6, links = [[0,1],[1,2],[2,3],[3,4],[4,5]], start = 0, maintenance = [3]. From tower 0 we reach 1 and 2. Tower 3 is blocked, so we cannot reach 4 or 5. The visited set is {0, 1, 2}, giving a count of 3.

When there is no maintenance, the signal reaches the whole connected component of the start — for example, all 5 towers in the path from 3. And when the start is isolated with no links, only the start is counted, giving 1.

The time complexity is O(n + e) where e is the number of links, 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

class Solution {
    public int has_segment_sum(int n, int[][] links, int start, int[] closed) {
        boolean[] blocked = new boolean[n];
        for (int x : closed) blocked[x] = true;
        if (blocked[start]) return 0;
        java.util.List<Integer>[] g = new java.util.ArrayList[n];
        for (int i = 0; i < n; i++) g[i] = new java.util.ArrayList<>();
        for (int[] e : links) { g[e[0]].add(e[1]); g[e[1]].add(e[0]); }
        boolean[] seen = new boolean[n];
        java.util.Stack<Integer> st = new java.util.Stack<>();
        seen[start] = true; st.push(start);
        while (!st.isEmpty()) {
            int u = st.pop();
            for (int w : g[u]) if (!seen[w] && !blocked[w]) { seen[w] = true; st.push(w); }
        }
        int cnt = 0; for (boolean b : seen) if (b) cnt++;
        return cnt;
    }
}

javascript

function has_segment_sum(n, links, start, closed) {
    var blocked = {};
    for (var i = 0; i < closed.length; i++) blocked[closed[i]] = true;
    if (blocked[start]) return 0;
    var g = [];
    for (var i = 0; i < n; i++) g[i] = [];
    for (var k = 0; k < links.length; k++) {
        var u = links[k][0], v = links[k][1];
        g[u].push(v); g[v].push(u);
    }
    var seen = {}; seen[start] = true; var stack = [start];
    while (stack.length) {
        var u = stack.pop();
        for (var j = 0; j < g[u].length; j++) {
            var w = g[u][j];
            if (!seen[w] && !blocked[w]) { seen[w] = true; stack.push(w); }
        }
    }
    var cnt = 0; for (var key in seen) cnt++;
    return cnt;
}

php

<?php
function has_segment_sum($n, $links, $start, $closed) {
    $blocked = [];
    foreach ($closed as $x) $blocked[$x] = true;
    if (isset($blocked[$start])) return 0;
    $g = array_fill(0, $n, []);
    foreach ($links as $e) { $g[$e[0]][] = $e[1]; $g[$e[1]][] = $e[0]; }
    $seen = [$start => true]; $stack = [$start];
    while (count($stack)) {
        $u = array_pop($stack);
        foreach ($g[$u] as $w) if (!isset($seen[$w]) && !isset($blocked[$w])) { $seen[$w] = true; $stack[] = $w; }
    }
    return count($seen);
}

python

def has_segment_sum(n: int, links: list, start: int, closed: list) -> int:
    blocked = set(closed)
    if start in blocked: return 0
    g = {i: [] for i in range(n)}
    for u, v in links:
        g[u].append(v); g[v].append(u)
    seen = {start}; stack = [start]
    while stack:
        u = stack.pop()
        for w in g[u]:
            if w not in seen and w not in blocked:
                seen.add(w); stack.append(w)
    return len(seen)

rust

use std::collections::HashSet;
pub fn has_segment_sum(n: i32, links: Vec<Vec<i32>>, start: i32, closed: Vec<i32>) -> i32 {
    let n = n as usize;
    let mut blocked = HashSet::new();
    for x in closed { blocked.insert(x); }
    if blocked.contains(&start) { return 0; }
    let mut g = vec![Vec::new(); n];
    for e in links {
        g[e[0] as usize].push(e[1]);
        g[e[1] as usize].push(e[0]);
    }
    let mut seen = HashSet::new();
    seen.insert(start);
    let mut st = vec![start];
    while let Some(u) = st.pop() {
        for &w in &g[u as usize] {
            if !blocked.contains(&w) && seen.insert(w) { st.push(w); }
        }
    }
    seen.len() as i32
}

typescript

function has_segment_sum(n: number, links: number[][], start: number, closed: number[]): number {
    var blocked: { [key: number]: boolean } = {};
    for (var i = 0; i < closed.length; i++) blocked[closed[i]] = true;
    if (blocked[start]) return 0;
    var g: number[][] = [];
    for (var i = 0; i < n; i++) g[i] = [];
    for (var k = 0; k < links.length; k++) {
        var u = links[k][0], v = links[k][1];
        g[u].push(v); g[v].push(u);
    }
    var seen: { [key: number]: boolean } = {}; seen[start] = true;
    var stack: number[] = [start];
    while (stack.length) {
        var u = stack.pop();
        for (var j = 0; j < g[u].length; j++) {
            var w = g[u][j];
            if (!seen[w] && !blocked[w]) { seen[w] = true; stack.push(w); }
        }
    }
    var cnt = 0; for (var key in seen) cnt++;
    return cnt;
}

Related Array Challenges

Comments (0)

Join the Discussion

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

Harbor Signal Expansion Test

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

Disaster Relief Route Tracker

Riverside Power Grid Check

Campus Shuttle Loop Coverage

Harbor Ferry Route Planner

Skyway Signal Cluster

Museum Corridor Sweep

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.