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

There are n cities numbered from 0 to n-1. Given the array edges where edges[i] = [from_i, to_i, weight_i] represents a bidirectional and weighted edge between cities from_i and to_i, and given the integer distanceThreshold.

Return the city with the smallest number of cities that are reachable through some path and whose distance is at most distanceThreshold. If there are multiple such cities, return the city with the greatest number.

Notice that the distance of a path connecting cities i and j is equal to the sum of the edges' weights along that path.

Input & Output

Example 1 — Basic Linear Graph

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

› Output: 0

💡 Note: City 0 can reach city 1 (distance 3). City 1 can reach cities 0,2,3 (distances 3,2,3). City 2 can reach cities 1,3 (distances 2,1). City 3 can reach cities 1,2 (distances 3,1). City 0 has the fewest reachable cities (1), so return 0.

Example 2 — Disconnected Components

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

› Output: 3

💡 Note: Within threshold 2: City 0 can reach city 1 (distance 2). City 1 can reach cities 0,4 (distances 2,2). City 2 has no reachable neighbors. City 3 has no reachable neighbors. City 4 can reach city 1 (distance 2). Cities 2 and 3 both have 0 reachable neighbors, so return the larger index 3.

Example 3 — Single City

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

› Output: 0

💡 Note: Only one city exists, so it has 0 reachable neighbors and is the answer by default.

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.

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8 f Facebook 6

The key insight is to use Floyd-Warshall algorithm to compute all-pairs shortest paths, then count reachable neighbors within the threshold for each city. Best approach is Floyd-Warshall with Time: O(n³), Space: O(n²).

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

DFS for Each City Pair

⏱️ Time: O(n × 2^n) Space: O(n)

For each city, perform DFS to all other cities to find the shortest paths within the distance threshold. This approach explores all possible paths recursively.

Floyd-Warshall Algorithm

⏱️ Time: O(n³) Space: O(n²)

Apply Floyd-Warshall algorithm to find shortest distances between all pairs of cities, then count neighbors within threshold for each city. This is the most efficient approach for dense graphs.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 100
#define INF 1000000000

int solution(int n, int edges[][3], int edgeCount, int distanceThreshold) {
    // Initialize distance matrix with infinity
    static int dist[MAX_N][MAX_N];
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dist[i][j] = INF;
        }
    }
    
    // Distance from a city to itself is 0
    for (int i = 0; i < n; i++) {
        dist[i][i] = 0;
    }
    
    // Fill in the direct edges
    for (int i = 0; i < edgeCount; i++) {
        int from_city = edges[i][0];
        int to_city = edges[i][1];
        int weight = edges[i][2];
        dist[from_city][to_city] = weight;
        dist[to_city][from_city] = weight;
    }
    
    // Floyd-Warshall algorithm
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }
    
    // Count reachable cities for each city
    int min_count = INT_MAX;
    int result_city = -1;
    
    for (int i = 0; i < n; i++) {
        int count = 0;
        for (int j = 0; j < n; j++) {
            if (i != j && dist[i][j] <= distanceThreshold) {
                count++;
            }
        }
        
        // If count is smaller, or equal but city number is greater
        if (count < min_count || (count == min_count && i > result_city)) {
            min_count = count;
            result_city = i;
        }
    }
    
    return result_city;
}

int parseEdges(char* edgesStr, int edges[][3]) {
    if (strcmp(edgesStr, "[]") == 0) {
        return 0;
    }
    
    int edgeCount = 0;
    char* ptr = edgesStr + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            edges[edgeCount][0] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            edges[edgeCount][1] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            edges[edgeCount][2] = strtol(ptr, &ptr, 10);
            edgeCount++;
        }
        ptr++;
    }
    
    return edgeCount;
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    int n = strtol(line, NULL, 10);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    static int edges[1000][3];
    int edgeCount = parseEdges(line, edges);
    
    fgets(line, sizeof(line), stdin);
    int distanceThreshold = strtol(line, NULL, 10);
    
    int result = solution(n, edges, edgeCount, distanceThreshold);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

892 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