Mountain Cabin Signal Range

String Easy 2 views

Like30

Mountain cabins are linked by suspension bridges. Your mission in Mountain Cabin Signal Range is to find how many unique cabins can receive a signal from a starting origin without crossing any Blocked Bridges. You treat the cabins as nodes and the bridges as edges in a network map.

The "secret sauce" here is Graph Traversal with Edge Filters. Using BFS or DFS, explore every possible path from the start cabin while immediately skipping any bridge in the blocked_bridges list. Duplicate or reversed entries in the data shouldn't change the reachable count. Every accessible cabin is counted once, and the starting point always counts as a recipient. This audit tells the coordinator exactly which parts of the mountain are currently in sync! It’s an essential skill for building logistics or disaster relief routing software under dynamic constraints.

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, bridges = [[0,1],[1,2],[2,3],[3,4],[4,5]], start = 0, blocked_bridges = [[2,3]]

Output

Explanation

Cabins 0, 1, and 2 receive the alert before reaching the blocked bridge between cabins 2 and 3.

Example 2

Input

n = 4, bridges = [[0,1],[1,2]], start = 3, blocked_bridges = [[2,1]]

Output

Explanation

Cabin 3 stands alone, so only the origin is counted.

Example 3

Input

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

Output

Explanation

With no blocked bridges, the signal reaches every cabin in the connected component.

Algorithm Flow

Recommendation Algorithm Flow for Mountain Cabin Signal Range - Budibadu

Best Answers

java

class Solution {
    public double calculate_min_range(int[][] cabins) {
        int n = cabins.length;
        if (n <= 1) return 0.0;
        double[] minD = new double[n];
        Arrays.fill(minD, Double.MAX_VALUE);
        minD[0] = 0.0;
        boolean[] visited = new boolean[n];
        double res = 0.0;
        for (int i = 0; i < n; i++) {
            int u = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && (u == -1 || minD[j] < minD[u])) u = j;
            }
            visited[u] = true;
            res = Math.max(res, minD[u]);
            for (int v = 0; v < n; v++) {
                if (!visited[v]) {
                    double d = Math.sqrt(Math.pow(cabins[u][0] - cabins[v][0], 2) + Math.pow(cabins[u][1] - cabins[v][1], 2));
                    minD[v] = Math.min(minD[v], d);
                }
            }
        }
        return res;
    }
}

javascript

function calculate_min_range(cabins) {
    const n = cabins.length;
    if (n <= 1) return 0;
    const dist = (p1, p2) => Math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2);
    const minD = new Array(n).fill(Infinity);
    minD[0] = 0;
    const visited = new Array(n).fill(false);
    let res = 0;
    for (let i = 0; i < n; i++) {
        let u = -1;
        for (let j = 0; j < n; j++) {
            if (!visited[j] && (u === -1 || minD[j] < minD[u])) u = j;
        }
        visited[u] = true;
        res = Math.max(res, minD[u]);
        for (let v = 0; v < n; v++) {
            if (!visited[v]) minD[v] = Math.min(minD[v], dist(cabins[u], cabins[v]));
        }
    }
    return res;
}

php

function calculate_min_range($cabins) {
    $n = count($cabins);
    if ($n <= 1) return 0;
    $dist = function($p1, $p2) {
        return sqrt(pow($p1[0]-$p2[0], 2) + pow($p1[1]-$p2[1], 2));
    };
    $minD = array_fill(0, $n, INF);
    $minD[0] = 0;
    $visited = array_fill(0, $n, false);
    $res = 0;
    for ($i = 0; $i < $n; $i++) {
        $u = -1;
        for ($j = 0; $j < $n; $j++) {
            if (!$visited[$j] && ($u == -1 || $minD[$j] < $minD[$u])) $u = $j;
        }
        $visited[$u] = true;
        $res = max($res, $minD[$u]);
        for ($v = 0; $v < $n; $v++) {
            if (!$visited[$v]) $minD[$v] = min($minD[$v], $dist($cabins[$u], $cabins[$v]));
        }
    }
    return $res;
}

python

import math
def calculate_min_range(cabins: list) -> float:
    n = len(cabins)
    if n <= 1: return 0.0
    def dist(p1, p2):
        return math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)
    min_d = [float('inf')] * n
    min_d[0] = 0.0
    visited = [False] * n
    res = 0.0
    for _ in range(n):
        u = -1
        for i in range(n):
            if not visited[i] and (u == -1 or min_d[i] < min_d[u]):
                u = i
        visited[u] = True
        res = max(res, min_d[u])
        for v in range(n):
            if not visited[v]:
                min_d[v] = min(min_d[v], dist(cabins[u], cabins[v]))
    return res

rust

pub fn calculate_min_range(cabins: Vec<Vec<i32>>) -> f64 {
    let n = cabins.len();
    if n <= 1 { return 0.0; }
    let mut min_d = vec![f64::MAX; n];
    min_d[0] = 0.0;
    let mut visited = vec![false; n];
    let mut res = 0.0;
    for _ in 0..n {
        let mut u = None;
        for i in 0..n {
            if !visited[i] && (u.is_none() || min_d[i] < min_d[u.unwrap()]) { u = Some(i); }
        }
        let u = u.unwrap();
        visited[u] = true;
        res = res.max(min_d[u]);
        for v in 0..n {
            if !visited[v] {
                let d = (((cabins[u][0] - cabins[v][0]).pow(2) + (cabins[u][1] - cabins[v][1]).pow(2)) as f64).sqrt();
                min_d[v] = min_d[v].min(d);
            }
        }
    }
    res
}

typescript

function calculate_min_range(cabins: number[][]): number {
    const n = cabins.length;
    if (n <= 1) return 0;
    const dist = (p1: number[], p2: number[]) => Math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2);
    const minD = new Array(n).fill(Infinity);
    minD[0] = 0;
    const visited = new Array(n).fill(false);
    let res = 0;
    for (let i = 0; i < n; i++) {
        let u = -1;
        for (let j = 0; j < n; j++) {
            if (!visited[j] && (u === -1 || minD[j] < minD[u])) u = j;
        }
        visited[u] = true;
        res = Math.max(res, minD[u]);
        for (let v = 0; v < n; v++) {
            if (!visited[v]) minD[v] = Math.min(minD[v], dist(cabins[u], cabins[v]));
        }
    }
    return res;
}

Comments (0)

Join the Discussion

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

Mountain Cabin Signal Range

Examples

Algorithm Flow

Best Answers

Solutions Coming Soon

Related String Problems

Wildlife Bridge Network Scan

Equinox Gate Verdict

Reverse String

Check Palindrome

Vowel Counter

String Length

Comments (0)

Join the Discussion