Garden Relay Count

Array Easy 1 views

Like7

During the solar festival, runners pass flower batons along a linear garden trail. In Garden Relay Count, your goal is to determine the length of the longest contiguous segment where the baton IDs alternate between even and odd. This balance represents a rhythmic flow that Curators use to time the festival’s choreography. Any break in this alternating rhythm ends the current segment immediately!

The "secret sauce" here is a Linear Streak Tracker. You walk through the array and check the parity of the current ID against the one before it. If they differ, your current streak grows. If they match, the rhythm is broken, and you must "reset" your streak count back to 1. By keeping track of the highest count found during your scan, you can find the peak duration of the garden’s balanced flow in O(n) time. This ensures you can process thousands of runners efficiently before the parade starts!

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 = 4, paths = [[0,1],[2,2]], start = 3, max_steps = 3

Output

Explanation

Garden 3 has no usable link, so only the starting location hears the relay.

Example 2

Input

n = 6, paths = [[0,1],[1,2],[2,3],[3,0],[4,5]], start = 2, max_steps = 1

Output

Explanation

Starting at garden 2 lets the caretakers reach gardens 1 and 3 within one hop.

Example 3

Input

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

Output

Explanation

The relay covers gardens 0, 1, and 2 before the hop limit stops the signal.

Algorithm Flow

Recommendation Algorithm Flow for Garden Relay Count - Budibadu

Best Answers

java

import java.util.*;
class Solution {
    public int garden_relay_count(int n, int[][] paths, int start, int max_steps) {
        if (n <= 0) return 0;
        List<List<Integer>> adj = new ArrayList<>();
        for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
        for (int[] p : paths) {
            if (p.length < 2) continue;
            int u = p[0], v = p[1];
            if (u < n && v < n) {
                adj.get(u).add(v);
                adj.get(v).add(u);
            }
        }
        boolean[] visited = new boolean[n];
        Queue<int[]> q = new LinkedList<>();
        q.add(new int[]{start, 0});
        visited[start] = true;
        int count = 1;
        while (!q.isEmpty()) {
            int[] curr = q.poll();
            int u = curr[0], d = curr[1];
            if (d < max_steps) {
                for (int v : adj.get(u)) {
                    if (!visited[v]) {
                        visited[v] = true;
                        q.add(new int[]{v, d + 1});
                        count++;
                    }
                }
            }
        }
        return count;
    }
}

javascript

function garden_relay_count(n, paths, start, max_steps) {
    const graph = Array.from({ length: n }, () => []);
    for (const [u, v] of paths) {
        if (u < n && v < n) {
            graph[u].push(v);
            graph[v].push(u);
        }
    }
    const visited = new Set([start]);
    const queue = [[start, 0]];
    let head = 0;
    while (head < queue.length) {
        const [u, d] = queue[head++];
        if (d < max_steps) {
            for (const v of graph[u]) {
                if (!visited.has(v)) {
                    visited.add(v);
                    queue.push([v, d + 1]);
                }
            }
        }
    }
    return visited.size;
}

php

<?php
function garden_relay_count($n, $paths, $start, $max_steps) {
    $graph = array_fill(0, $n, []);
    foreach ($paths as $path) {
        if ($path[0] < $n && $path[1] < $n) {
            $graph[$path[0]][] = $path[1];
            $graph[$path[1]][] = $path[0];
        }
    }
    $visited = [$start => true];
    $queue = [[$start, 0]];
    $head = 0;
    while ($head < count($queue)) {
        list($u, $d) = $queue[$head++];
        if ($d < $max_steps) {
            foreach ($graph[$u] as $v) {
                if (!isset($visited[$v])) {
                    $visited[$v] = true;
                    $queue[] = [$v, $d + 1];
                }
            }
        }
    }
    return count($visited);
}

python

from collections import deque
from typing import List

def garden_relay_count(n: int, paths: List[List[int]], start: int, max_steps: int) -> int:
    graph = [[] for _ in range(n)]
    for u, v in paths:
        if u < n and v < n:
            graph[u].append(v)
            graph[v].append(u)
    visited = {start}
    queue = deque([(start, 0)])
    while queue:
        u, d = queue.popleft()
        if d < max_steps:
            for v in graph[u]:
                if v not in visited:
                    visited.add(v)
                    queue.append((v, d + 1))
    return len(visited)

rust


pub fn garden_relay_count(n: i32, paths: Vec<Vec<i32>>, start: i32, max_steps: i32) -> i32 {
    let n = n as usize;
    let mut graph = vec![vec![]; n];
    for path in paths {
        let u = path[0] as usize;
        let v = path[1] as usize;
        if u < n && v < n {
            graph[u].push(v);
            graph[v].push(u);
        }
    }
    let mut visited = vec![false; n];
    let start = start as usize;
    visited[start] = true;
    let mut queue = std::collections::VecDeque::new();
    queue.push_back((start, 0));
    let mut count = 1;
    while let Some((u, d)) = queue.pop_front() {
        if d < max_steps {
            for &v in &graph[u] {
                if !visited[v] {
                    visited[v] = true;
                    queue.push_back((v, d + 1));
                    count += 1;
                }
            }
        }
    }
    count
}

typescript

function garden_relay_count(n: number, paths: number[][], start: number, max_steps: number): number {
    const graph: number[][] = [];
    for (let i = 0; i < n; i++) graph[i] = [];
    for (let i = 0; i < paths.length; i++) {
        const [u, v] = paths[i];
        if (u < n && v < n) {
            graph[u].push(v);
            graph[v].push(u);
        }
    }
    const visited: { [key: number]: boolean } = {};
    const queue: [number, number][] = [[start, 0]];
    visited[start] = true;
    let head = 0;
    let count = 1;
    while (head < queue.length) {
        const [u, d] = queue[head++];
        if (d < max_steps) {
            const neighbors = graph[u];
            for (let i = 0; i < neighbors.length; i++) {
                const v = neighbors[i];
                if (!visited[v]) {
                    visited[v] = true;
                    queue.push([v, d + 1]);
                    count++;
                }
            }
        }
    }
    return count;
}

Comments (0)

Join the Discussion

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

Garden Relay Count

Examples

Algorithm Flow

Best Answers

Solutions Coming Soon

Related Array Problems

Longest Consecutive Sequence

Lantern Stall Picks

Festival Stall Order

Studio Lighting Slots

Seaport Ferry Gate Control

Railway Network Delay Optimizer

Comments (0)

Join the Discussion