Museum Corridor Sweep

Array Easy 1 views

Like24

The museum’s security team monitors corridors linked by sensors (0 to n-1). During a system upgrade, certain corridor segments are Offline. Your mission in Museum Corridor Sweep is to find the Shortest Path (minimum number of sensor points) to move from a specific start area to an exit while avoiding all offline zones.

The "secret sauce" here is Breadth-First Search (BFS). Since you want the quickest route through the layout, BFS is the gold standard. It explores level by level, ensuring the first time you reach the exit, you've found the shortest possible path. Crucially, you must skip any nodes in the offline_zones list. If no path exists, return -1 correctly. This sweep ensures the guards can respond to alarms instantly, even when the facility's map is partially limited. It’s a practical application of grid or network navigation and a cornerstone of modern security logistics!

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

Output

Explanation

Rooms 0, 1, and 2 form one connected section; rooms 3 and 4 are separate.

Example 2

Input

n = 4, corridors = [[0,1],[2,3]], start = 2

Output

Explanation

The sweep reaches rooms 2 and 3; the other rooms remain unchecked.

Example 3

Input

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

Output

Explanation

The sweep moves through every room in sequence without revisiting any room.

Algorithm Flow

Recommendation Algorithm Flow for Museum Corridor Sweep - Budibadu

Best Answers

java

import java.util.*;
class Solution {
    public int calculate_min_workers(int[][] workers, int length) {
        Arrays.sort(workers, (a, b) -> a[0] - b[0]);
        int res = 0, currentFar = 0, i = 0;
        while (currentFar < length) {
            int nextFar = currentFar;
            while (i < workers.length && workers[i][0] <= currentFar) {
                nextFar = Math.max(nextFar, workers[i][1]);
                i++;
            }
            if (nextFar == currentFar) return -1;
            res++;
            currentFar = nextFar;
        }
        return res;
    }
}

javascript

function calculate_min_workers(workers, length) {
    workers.sort((a, b) => a[0] - b[0]);
    let res = 0, currentFar = 0, i = 0;
    while (currentFar < length) {
        let nextFar = currentFar;
        while (i < workers.length && workers[i][0] <= currentFar) {
            nextFar = Math.max(nextFar, workers[i][1]);
            i++;
        }
        if (nextFar === currentFar) return -1;
        res++;
        currentFar = nextFar;
    }
    return res;
}

php

function calculate_min_workers($workers, $length) {
    usort($workers, function($a, $b) { return $a[0] - $b[0]; });
    $res = 0; $currentFar = 0; $i = 0;
    while ($currentFar < $length) {
        $nextFar = $currentFar;
        while ($i < count($workers) && $workers[$i][0] <= $currentFar) {
            $nextFar = max($nextFar, $workers[$i][1]);
            $i++;
        }
        if ($nextFar == $currentFar) return -1;
        $res++;
        $currentFar = $nextFar;
    }
    return $res;
}

python

def calculate_min_workers(workers: list, length: int) -> int:
    workers.sort()
    res = 0
    current_far = 0
    i = 0
    while current_far < length:
        next_far = current_far
        while i < len(workers) and workers[i][0] <= current_far:
            next_far = max(next_far, workers[i][1])
            i += 1
        if next_far == current_far: return -1
        res += 1
        current_far = next_far
    return res

rust

pub fn calculate_min_workers(workers: Vec<Vec<i32>>, length: i32) -> i32 {
    let mut workers = workers;
    workers.sort_by_key(|w| w[0]);
    let mut res = 0;
    let mut current_far = 0;
    let mut i = 0;
    while current_far < length {
        let mut next_far = current_far;
        while i < workers.len() && workers[i][0] <= current_far {
            next_far = std::cmp::max(next_far, workers[i][1]);
            i += 1;
        }
        if next_far == current_far { return -1; }
        res += 1;
        current_far = next_far;
    }
    res
}

typescript

function calculate_min_workers(workers: number[][], length: number): number {
    workers.sort((a, b) => a[0] - b[0]);
    let res = 0, currentFar = 0, i = 0;
    while (currentFar < length) {
        let nextFar = currentFar;
        while (i < workers.length && workers[i][0] <= currentFar) {
            nextFar = Math.max(nextFar, workers[i][1]);
            i++;
        }
        if (nextFar === currentFar) return -1;
        res++;
        currentFar = nextFar;
    }
    return res;
}

Comments (0)

Join the Discussion

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

Museum Corridor Sweep

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

Seaport Ferry Gate Control

Comments (0)

Join the Discussion