Minimum Score of a Path Between Two Cities

Minimum Score of a Path Between Two Cities - Problem

You are given a positive integer n representing n cities numbered from 1 to n. You are also given a 2D array roads where roads[i] = [ai, bi, distancei] indicates that there is a bidirectional road between cities ai and bi with a distance equal to distancei. The cities graph is not necessarily connected.

The score of a path between two cities is defined as the minimum distance of a road in this path.

Return the minimum possible score of a path between cities 1 and n.

Note:

A path is a sequence of roads between two cities.
It is allowed for a path to contain the same road multiple times, and you can visit cities 1 and n multiple times along the path.
The test cases are generated such that there is at least one path between 1 and n.

Input & Output

Example 1 — 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: 1 → 4 has minimum road distance 7. But we can go 1 → 2 → 4 with minimum road distance min(9,5) = 5, which is better.

Example 2 — Direct Connection

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

› Output: 2

💡 Note: Path 1 → 2 → 1 → 3 → 4 uses roads with distances [2,2,4,7], minimum is 2.

Constraints

2 ≤ n ≤ 10⁵
1 ≤ roads.length ≤ 10⁵
roads[i].length == 3
1 ≤ a_i, b_i ≤ n
a_i ≠ b_i
1 ≤ distance_i ≤ 10⁴

Visualization

Tap to expand

Asked in

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

The key insight is that since we can reuse roads multiple times, we just need to find the minimum edge weight in the connected component containing both cities 1 and n. Best approach uses DFS/BFS to explore the connected component. Time: O(V + E), Space: O(V + E)

Common Approaches

✓ BFS Exploration

⏱️ Time: O(V + E) Space: O(V + E)

Similar to DFS but uses BFS to explore the connected component. Since we can reuse roads, we just need to find the minimum edge weight in the connected component containing both cities 1 and n.

DFS Exploration

⏱️ Time: O(V + E) Space: O(V + E)

Since we can reuse roads multiple times, we just need to find all roads reachable from city 1 and return the minimum distance among them. We use DFS to explore the connected component.

Union-Find with Edge Sorting

⏱️ Time: O(E log E) Space: O(V)

Since we can reuse roads multiple times, we need the minimum edge in the connected component. Sort edges by weight and use Union-Find to track when cities 1 and n become connected.

BFS Exploration — Algorithm Steps

Build adjacency list from roads
Start BFS from city 1
Track minimum road distance while exploring

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Begin from city 1, add to queue

Explore Level

Process all neighbors at current level

Track Minimum

Update minimum distance as edges are encountered

Code -

solution.c — C

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

typedef struct Edge {
    int to, dist;
    struct Edge* next;
} Edge;

typedef struct {
    Edge* head;
} AdjList;

typedef struct {
    int data[100000];
    int front, rear;
} Queue;

int visited[100001];

void enqueue(Queue* q, int val) {
    q->data[q->rear++] = val;
}

int dequeue(Queue* q) {
    return q->data[q->front++];
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

void parseArray(const char* str, int roads[][3], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        if (*p == '[') {
            p++;
            roads[*size][0] = (int)strtol(p, (char**)&p, 10);
            while (*p == ',' || *p == ' ') p++;
            roads[*size][1] = (int)strtol(p, (char**)&p, 10);
            while (*p == ',' || *p == ' ') p++;
            roads[*size][2] = (int)strtol(p, (char**)&p, 10);
            (*size)++;
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
        } else {
            p++;
        }
    }
}

int solution(int n, int roads[][3], int roadsSize) {
    AdjList graph[100001];
    for (int i = 0; i <= n; i++) {
        graph[i].head = NULL;
        visited[i] = 0;
    }
    
    for (int i = 0; i < roadsSize; i++) {
        int a = roads[i][0], b = roads[i][1], dist = roads[i][2];
        
        Edge* edge1 = malloc(sizeof(Edge));
        edge1->to = b;
        edge1->dist = dist;
        edge1->next = graph[a].head;
        graph[a].head = edge1;
        
        Edge* edge2 = malloc(sizeof(Edge));
        edge2->to = a;
        edge2->dist = dist;
        edge2->next = graph[b].head;
        graph[b].head = edge2;
    }
    
    Queue q = {.front = 0, .rear = 0};
    enqueue(&q, 1);
    visited[1] = 1;
    int minScore = INT_MAX;
    
    while (!isEmpty(&q)) {
        int city = dequeue(&q);
        
        Edge* edge = graph[city].head;
        while (edge) {
            if (edge->dist < minScore) {
                minScore = edge->dist;
            }
            if (!visited[edge->to]) {
                visited[edge->to] = 1;
                enqueue(&q, edge->to);
            }
            edge = edge->next;
        }
    }
    
    return minScore;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    
    int roads[1000][3];
    int roadsSize = 0;
    
    parseArray(line, roads, &roadsSize);
    
    printf("%d\n", solution(n, roads, roadsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex and edge once in BFS traversal

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage and BFS queue

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Constraints

Visualization

Related Problems

Common Approaches

BFS Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler