Minimum Score of a Path Between Two Cities

Minimum Score of a Path Between Two Cities - Problem

You're planning a road trip across n cities numbered from 1 to n. You have a detailed map represented by a 2D array roads where roads[i] = [a_i, b_i, distance_i] indicates a bidirectional road between cities a_i and b_i with the given distance.

Here's the twist: the score of any path is determined by the shortest road segment you encounter along the way. Think of it as the "weakest link" in your journey - if you're driving a large truck, your path's capability is limited by the narrowest road you must use.

Your goal: Find the minimum possible score for any path between city 1 and city n.

Important rules:

You can use the same road multiple times
You can visit cities multiple times
A path is guaranteed to exist between cities 1 and n

The key insight is that since you can traverse roads multiple times and visit cities repeatedly, you need to find the minimum distance road in the entire connected component containing both cities 1 and n.

Input & Output

example_1.py — Basic Path

$ Input: n = 4, roads = [[1,2,9],[2,3,6],[2,4,5],[1,4,7]]

› Output: 5

💡 Note: The path from city 1 to 4 with minimum score is: 1 → 4 (score = 7) or 1 → 2 → 4 (score = min(9,5) = 5). However, since we can reuse roads, we can take: 1 → 2 → 4 → 2 → 4, which gives us access to edge (2,4) with weight 5, making 5 the minimum possible score.

example_2.py — Indirect Path

$ Input: n = 4, roads = [[1,2,2],[1,3,4],[3,4,7]]

› Output: 2

💡 Note: Cities 1 and 4 are in the same connected component. The path could be 1 → 2 → 1 → 3 → 4, which allows us to use the edge (1,2) with weight 2, the minimum in the component.

example_3.py — Direct Connection

$ Input: n = 2, roads = [[1,2,3]]

› Output: 3

💡 Note: Only one road connects cities 1 and 2, so the minimum score is 3.

Visualization

Tap to expand

Understanding the Visualization

Map the Network

Build a map of all connected roads from your starting depot

Explore Freely

Since detours are free, explore the entire connected road network

Find Bottleneck

Identify the narrowest road (minimum weight) in the entire network

Optimal Route

Any route using this narrowest road gives the best possible score

Key Takeaway

🎯 Key Insight: With unlimited road reuse, the problem reduces to finding the minimum edge weight in the connected component containing both start and end cities.

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex and edge at most once during BFS/DFS traversal

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage plus BFS queue or DFS recursion stack

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
1 ≤ roads.length ≤ 2 × 10⁵
roads[i].length == 3
1 ≤ a_i, b_i ≤ n
a_i ≠ b_i
1 ≤ distance_i ≤ 10⁴
There is at least one path between cities 1 and n

Asked in

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

The optimal approach uses BFS/DFS to explore the connected component containing cities 1 and n. Since we can reuse roads and revisit cities, the answer is simply the minimum edge weight in the entire connected component. This insight transforms the problem from complex path optimization to simple graph traversal with O(V + E) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Connected Component + Min Edge	O(V + E)	O(V + E)	Find connected component containing cities 1 and n, return minimum edge weight

Connected Component + Min Edge — Algorithm Steps

Build adjacency list representation of the graph
Use BFS or DFS to find all cities reachable from city 1
While exploring, track the minimum edge weight encountered
Return the minimum edge weight in the connected component

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Begin BFS from city 1, initialize minimum distance tracker

Explore Neighbors

For each city, examine all adjacent roads and update minimum

Track Minimum

Keep track of the smallest edge weight seen so far

Return Result

After exploring the entire component, return minimum edge weight

Code -

solution.c — C

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

#define MAX_N 10000
#define MAX_QUEUE 10000

int graph[MAX_N][MAX_N * 2];  // Store [neighbor, distance] pairs
int graphSize[MAX_N];
int visited[MAX_N];
int queue[MAX_QUEUE];
int front = 0, rear = 0;

void enqueue(int x) {
    queue[rear++] = x;
}

int dequeue() {
    return queue[front++];
}

int isEmpty() {
    return front == rear;
}

int minScore(int n, int roads[][3], int roadsSize) {
    // Initialize
    for (int i = 0; i <= n; i++) {
        graphSize[i] = 0;
        visited[i] = 0;
    }
    front = rear = 0;
    
    // Build adjacency list
    for (int i = 0; i < roadsSize; i++) {
        int a = roads[i][0], b = roads[i][1], dist = roads[i][2];
        graph[a][graphSize[a]++] = b;
        graph[a][graphSize[a]++] = dist;
        graph[b][graphSize[b]++] = a;
        graph[b][graphSize[b]++] = dist;
    }
    
    // BFS to find connected component starting from city 1
    enqueue(1);
    visited[1] = 1;
    int minDistance = INT_MAX;
    
    while (!isEmpty()) {
        int city = dequeue();
        
        for (int i = 0; i < graphSize[city]; i += 2) {
            int neighbor = graph[city][i];
            int dist = graph[city][i + 1];
            
            if (dist < minDistance) {
                minDistance = dist;
            }
            
            if (!visited[neighbor]) {
                visited[neighbor] = 1;
                enqueue(neighbor);
            }
        }
    }
    
    return minDistance;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex and edge at most once during BFS/DFS traversal

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage plus BFS queue or DFS recursion stack

✓ Linear Space

Constraints

2 ≤ n ≤ 10⁵
1 ≤ roads.length ≤ 2 × 10⁵
roads[i].length == 3
1 ≤ a_i, b_i ≤ n
a_i ≠ b_i
1 ≤ distance_i ≤ 10⁴
There is at least one path between cities 1 and n

25.6K Views

Medium Frequency

~15 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Connected Component + Min Edge — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler