Skyway Signal Cluster

Published at05 Jan 2026

Array Array Manipulation Easy 7 views

Like6

This problem feels like a little puzzle you can solve one step at a time. In Skyway Signal Cluster, you are trying to work toward the right number by following one clear idea.

Find skyway signal cluster coverage 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 = 4, connectors = [], start = 1, the answer is 1. With no connectors, the broadcast remains at the starting deck. Another example is n = 5, connectors = [[0,1],[1,2],[2,3],[3,4]], start = 2, which gives 5. Every deck is connected through the chain, so the broadcast covers all decks.

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 = 4, connectors = [], start = 1

Output

Explanation

With no connectors, the broadcast remains at the starting deck.

Example 2

Input

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

Output

Explanation

Every deck is connected through the chain, so the broadcast covers all decks.

Example 3

Input

n = 6, connectors = [[0,1],[2,3],[3,4],[4,2]], start = 3

Output

Explanation

The cluster includes decks 2, 3, and 4; the other decks are unreachable.

Algorithm Flow

Recommendation Algorithm Flow for Skyway Signal Cluster

Solution Approach

This problem asks us to count the number of distinct signal clusters in a grid. A cluster is a group of connected 1 cells, where cells connect only through their four direct neighbors (up, down, left, right). Diagonal cells do not belong to the same cluster.

The classic way to solve this is a grid traversal. We scan every cell, and whenever we find an unvisited 1, we have found a new cluster, so we count it and flood-fill to mark its whole cluster as visited.

Here is the implementation using an iterative flood fill:

function group_signal_patterns(grid) {
    if (!grid || grid.length === 0) return 0;
    const rows = grid.length, cols = grid[0].length;
    const visited = Array.from({ length: rows }, () => Array(cols).fill(false));
    let count = 0;
    const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]];
    for (let r = 0; r < rows; r++) {
        for (let c = 0; c < cols; c++) {
            if (grid[r][c] === 1 && !visited[r][c]) {
                count++;
                const stack = [[r, c]];
                visited[r][c] = true;
                while (stack.length > 0) {
                    const [cr, cc] = stack.pop();
                    for (const [dr, dc] of dirs) {
                        const nr = cr + dr, nc = cc + dc;
                        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols &&
                            grid[nr][nc] === 1 && !visited[nr][nc]) {
                            visited[nr][nc] = true;
                            stack.push([nr, nc]);
                        }
                    }
                }
            }
        }
    }
    return count;
}

We keep a visited grid and scan every cell. When we hit an unvisited 1, we increment the cluster count and start a flood fill from that cell. The fill uses the four direction offsets and marks every connected 1 as visited, so later cells in the same cluster are skipped.

Let us trace grid = [[1,1,0],[1,1,0],[0,0,1]]. The four 1 cells in the top-left corner form one connected cluster, and the single 1 at the bottom-right forms another, giving 2. For [[1,1],[1,1]], all four cells are connected into one cluster, so the answer is 1.

Diagonal-only cells, like the pattern [[1,0],[0,1]], are separate because they do not share a side. In the 3x3 example [[1,0,1],[0,1,0],[1,0,1]], every 1 is isolated diagonally, so there are 5 separate clusters.

The time complexity is O(rows * cols) because each cell is visited once, and the space complexity is O(rows * cols) for the visited grid.

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 group_signal_patterns(int[][] grid) {
        if (grid.length == 0) return 0;
        int count = 0;
        for (int r = 0; r < grid.length; r++)
            for (int c = 0; c < grid[0].length; c++)
                if (grid[r][c] == 1) { count++; dfs(grid, r, c); }
        return count;
    }
    private void dfs(int[][] g, int r, int c) {
        if (r < 0 || r >= g.length || c < 0 || c >= g[0].length || g[r][c] == 0) return;
        g[r][c] = 0;
        dfs(g, r-1, c); dfs(g, r+1, c); dfs(g, r, c-1); dfs(g, r, c+1);
    }
}

javascript

function group_signal_patterns(grid) {
    if (!grid.length) return 0;
    function dfs(r, c) {
        if (r < 0 || r >= grid.length || c < 0 || c >= grid[0].length || grid[r][c] === 0) return;
        grid[r][c] = 0;
        dfs(r-1, c); dfs(r+1, c); dfs(r, c-1); dfs(r, c+1);
    }
    var count = 0;
    for (var r = 0; r < grid.length; r++)
        for (var c = 0; c < grid[0].length; c++)
            if (grid[r][c] === 1) { count++; dfs(r, c); }
    return count;
}

php

<?php
function group_signal_patterns($grid) {
    if (count($grid) == 0) return 0;
    $count = 0;
    for ($r = 0; $r < count($grid); $r++)
        for ($c = 0; $c < count($grid[0]); $c++)
            if ($grid[$r][$c] == 1) { $count++; $grid = dfs_iso($grid, $r, $c); }
    return $count;
}
function dfs_iso($g, $r, $c) {
    if ($r < 0 || $r >= count($g) || $c < 0 || $c >= count($g[0]) || $g[$r][$c] == 0) return $g;
    $g[$r][$c] = 0;
    $g = dfs_iso($g, $r-1, $c); $g = dfs_iso($g, $r+1, $c); $g = dfs_iso($g, $r, $c-1); $g = dfs_iso($g, $r, $c+1);
    return $g;
}

python

def group_signal_patterns(grid: list) -> int:
    def dfs(r, c):
        if r < 0 or r >= len(grid) or c < 0 or c >= len(grid[0]) or grid[r][c] == 0:
            return
        grid[r][c] = 0
        dfs(r-1, c); dfs(r+1, c); dfs(r, c-1); dfs(r, c+1)
    count = 0
    for r in range(len(grid)):
        for c in range(len(grid[0])):
            if grid[r][c] == 1:
                count += 1
                dfs(r, c)
    return count

rust

pub fn group_signal_patterns(mut grid: Vec<Vec<i32>>) -> i32 {
    if grid.is_empty() { return 0; }
    let rows = grid.len();
    let cols = grid[0].len();
    fn dfs(g: &mut Vec<Vec<i32>>, r: usize, c: usize) {
        if r >= g.len() || c >= g[0].len() || g[r][c] == 0 { return; }
        g[r][c] = 0;
        if r > 0 { dfs(g, r-1, c); }
        if r + 1 < g.len() { dfs(g, r+1, c); }
        if c > 0 { dfs(g, r, c-1); }
        if c + 1 < g[0].len() { dfs(g, r, c+1); }
    }
    let mut count = 0;
    for r in 0..rows {
        for c in 0..cols {
            if grid[r][c] == 1 { count += 1; dfs(&mut grid, r, c); }
        }
    }
    count
}

typescript

function group_signal_patterns(grid: number[][]): number {
    if (grid.length === 0) return 0;
    function dfs(r: number, c: number): void {
        if (r < 0 || r >= grid.length || c < 0 || c >= grid[0].length || grid[r][c] === 0) return;
        grid[r][c] = 0;
        dfs(r-1, c); dfs(r+1, c); dfs(r, c-1); dfs(r, c+1);
    }
    var count = 0;
    for (var r = 0; r < grid.length; r++)
        for (var c = 0; c < grid[0].length; c++)
            if (grid[r][c] === 1) { count++; dfs(r, c); }
    return count;
}

Related Array Challenges

Comments (0)

Join the Discussion

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

Skyway Signal Cluster

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

Museum Corridor Sweep

Celestial Skyline Layout

Equinox Gate Verdict

Aurora Diary Synthesis

Ember Glyph Mosaic

Starfall Signal Map

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.