Find the City With the Smallest Number of Neighbors at a Threshold Distance

Find the City With the Smallest Number of Neighbors at a Threshold Distance - Problem

Imagine you're a logistics manager tasked with finding the most isolated city in a transportation network. You have n cities numbered from 0 to n-1, connected by bidirectional roads with specific travel costs.

Given an array edges where edges[i] = [from_i, to_i, weight_i] represents a bidirectional road between cities from_i and to_i with travel cost weight_i, and a distanceThreshold, you need to:

Find the city that can reach the fewest number of other cities within the distance threshold
If multiple cities have the same minimum count, return the one with the largest city number

The distance between cities is the sum of road weights along the shortest path connecting them.

Input & Output

example_1.py — Basic Graph

$ Input: n = 4, edges = [[0,1,3],[1,2,1],[1,3,4],[2,3,1]], distanceThreshold = 4

› Output: 3

💡 Note: The shortest distances are: City 0: can reach [1,2,3] with distances [3,4,5] → 2 cities within threshold. City 1: can reach [0,2,3] with distances [3,1,2] → 3 cities within threshold. City 2: can reach [0,1,3] with distances [4,1,1] → 3 cities within threshold. City 3: can reach [0,1,2] with distances [5,2,1] → 2 cities within threshold. Cities 0 and 3 have minimum count (2), so we return 3 (higher number).

example_2.py — Dense Graph

$ Input: n = 5, edges = [[0,1,2],[0,4,8],[1,2,3],[1,4,2],[2,3,1],[3,4,1]], distanceThreshold = 2

› Output: 0

💡 Note: With threshold 2, most cities can only reach 1-2 neighbors. City 0 can reach [1] with distance 2. City 1 can reach [0,4] with distances [2,2]. City 4 can reach [1,3] with distances [2,1]. After calculating all shortest paths, city 0 has the minimum reachable count.

example_3.py — Single City

$ Input: n = 1, edges = [], distanceThreshold = 1

› Output: 0

💡 Note: With only one city, city 0 has 0 reachable neighbors, making it the answer by default.

Visualization

Tap to expand

Understanding the Visualization

Network Analysis

Map all cities and transportation routes with travel costs

Distance Calculation

Calculate shortest response times between all city pairs

Coverage Assessment

Count how many cities each potential location can serve within time threshold

Optimal Selection

Choose location serving fewest cities (prefer newer facilities on ties)

Key Takeaway

🎯 Key Insight: Pre-computing all shortest paths with Floyd-Warshall enables efficient comparison of every potential response center location

Time & Space Complexity

Time Complexity

⏱️

O(n * (E + V) * log V)

Running Dijkstra n times, each taking O((E + V) * log V) time

⚡ Linearithmic

Space Complexity

O(V + E)

Space for adjacency list and priority queue in Dijkstra

✓ Linear Space

Constraints

2 ≤ n ≤ 100
1 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 3
0 ≤ from_i < to_i < n
1 ≤ weight_i, distanceThreshold ≤ 10⁴
All pairs (from_i, to_i) are distinct

Asked in

a Amazon 18 G Google 15 ⊞ Microsoft 12 f Meta 8

This is a shortest path problem that requires finding all-pairs shortest distances. The optimal approach uses Floyd-Warshall algorithm with O(n³) time complexity to pre-compute shortest paths between all city pairs, then counts reachable cities for each location. The key insight is that we need distances from every city to every other city, making Floyd-Warshall more efficient than running Dijkstra n times for dense graphs.

Common Approaches

Approach	Time	Space	Notes
✓ Dijkstra from Each City	O(n * (E + V) * log V)	O(V + E)	Run Dijkstra's algorithm from each city to find shortest distances
Floyd-Warshall All-Pairs Shortest Path (Optimal)	O(n³)	O(n²)	Pre-compute all shortest distances using Floyd-Warshall, then count reachable cities

Dijkstra from Each City — Algorithm Steps

For each city (0 to n-1), run Dijkstra's algorithm
Count cities reachable within distanceThreshold from current city
Track the city with minimum reachable count (prefer higher number on ties)
Return the optimal city

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from City 0

Run Dijkstra from city 0, calculate distances to all cities

Count Reachable

Count cities within distance threshold from city 0

Repeat for All

Repeat process for cities 1, 2, ..., n-1

Find Minimum

Choose city with minimum reachable count (prefer highest number)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define MAX_N 100
#define MAX_EDGES 1000

struct Edge {
    int to, weight;
};

struct Graph {
    struct Edge edges[MAX_EDGES];
    int count[MAX_N];
};

int dijkstra(struct Graph* graph, int start, int n, int threshold) {
    int distances[MAX_N];
    int visited[MAX_N] = {0};
    
    for (int i = 0; i < n; i++) {
        distances[i] = INT_MAX;
    }
    distances[start] = 0;
    
    for (int i = 0; i < n; i++) {
        int u = -1;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && (u == -1 || distances[j] < distances[u])) {
                u = j;
            }
        }
        
        if (distances[u] == INT_MAX) break;
        visited[u] = 1;
        
        int edgeStart = 0;
        for (int k = 0; k < u; k++) {
            edgeStart += graph->count[k];
        }
        
        for (int k = 0; k < graph->count[u]; k++) {
            int v = graph->edges[edgeStart + k].to;
            int weight = graph->edges[edgeStart + k].weight;
            if (distances[u] + weight < distances[v]) {
                distances[v] = distances[u] + weight;
            }
        }
    }
    
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (distances[i] <= threshold && distances[i] > 0) {
            count++;
        }
    }
    return count;
}

int findTheCity(int n, int** edges, int edgesSize, int* edgesColSize, int distanceThreshold) {
    struct Graph graph;
    for (int i = 0; i < n; i++) {
        graph.count[i] = 0;
    }
    
    int edgeIndex = 0;
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1], w = edges[i][2];
        graph.edges[edgeIndex++] = (struct Edge){v, w};
        graph.count[u]++;
        graph.edges[edgeIndex++] = (struct Edge){u, w};
        graph.count[v]++;
    }
    
    int minReachable = INT_MAX;
    int resultCity = 0;
    
    for (int city = 0; city < n; city++) {
        int reachableCount = dijkstra(&graph, city, n, distanceThreshold);
        if (reachableCount <= minReachable) {
            minReachable = reachableCount;
            resultCity = city;
        }
    }
    
    return resultCity;
}

int main() {
    int* edges[4];
    int edge1[] = {0, 1, 3};
    int edge2[] = {1, 2, 1};
    int edge3[] = {1, 3, 4};
    int edge4[] = {2, 3, 1};
    edges[0] = edge1; edges[1] = edge2; edges[2] = edge3; edges[3] = edge4;
    int edgesColSize[] = {3, 3, 3, 3};
    
    printf("%d\n", findTheCity(4, edges, 4, edgesColSize, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * (E + V) * log V)

Running Dijkstra n times, each taking O((E + V) * log V) time

⚡ Linearithmic

Space Complexity

O(V + E)

Space for adjacency list and priority queue in Dijkstra

✓ Linear Space

Constraints

2 ≤ n ≤ 100
1 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 3
0 ≤ from_i < to_i < n
1 ≤ weight_i, distanceThreshold ≤ 10⁴
All pairs (from_i, to_i) are distinct

42.0K Views

Medium Frequency

~25 min Avg. Time

1.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dijkstra from Each City — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler