Second Minimum Time to Reach Destination

Second Minimum Time to Reach Destination - Problem

A city is represented as a bi-directional connected graph with n vertices where each vertex is labeled from 1 to n (inclusive). The edges in the graph are represented as a 2D integer array edges, where each edges[i] = [ui, vi] denotes a bi-directional edge between vertex ui and vertex vi. Every vertex pair is connected by at most one edge, and no vertex has an edge to itself.

The time taken to traverse any edge is time minutes. Each vertex has a traffic signal which changes its color from green to red and vice versa every change minutes. All signals change at the same time. You can enter a vertex at any time, but can leave a vertex only when the signal is green. You cannot wait at a vertex if the signal is green.

The second minimum value is defined as the smallest value strictly larger than the minimum value. For example, the second minimum value of [2, 3, 4] is 3, and the second minimum value of [2, 2, 4] is 4.

Given n, edges, time, and change, return the second minimum time it will take to go from vertex 1 to vertex n.

Note: You can go through any vertex any number of times, including 1 and n. You can assume that when the journey starts, all signals have just turned green.

Input & Output

Example 1 — Basic Graph

$ Input: n = 5, edges = [[1,2],[1,3],[1,4],[3,4],[4,5]], time = 3, change = 5

› Output: 13

💡 Note: First minimum path: 1→4→5 takes 6 time units. Second minimum: 1→3→4→5 or 1→2→1→4→5 takes 13 time units considering traffic light delays.

Example 2 — Simple Path

$ Input: n = 2, edges = [[1,2]], time = 3, change = 2

› Output: 11

💡 Note: Only one direct path 1→2. First minimum is 3. To get second minimum, go 1→2→1→2, which takes 11 time units with traffic delays.

Example 3 — Multiple Routes

$ Input: n = 4, edges = [[1,2],[1,3],[2,4],[3,4]], time = 2, change = 4

› Output: 6

💡 Note: Two paths: 1→2→4 and 1→3→4. Both take 4 time units (first minimum). Second minimum requires one detour, taking 6 time units.

Constraints

2 ≤ n ≤ 10⁴
n - 1 ≤ edges.length ≤ min(2 × 10⁴, n × (n - 1) / 2)
edges[i].length == 2
1 ≤ u_i, v_i ≤ n
u_i != v_i
There are no duplicate edges
The graph is connected
1 ≤ time, change ≤ 10³

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is to use a modified BFS/Dijkstra approach that tracks both the shortest and second shortest arrival times at each vertex while considering traffic light delays. The optimal approach uses a priority queue to process vertices by arrival time and maintains two distance values per vertex. Time: O(E log V), Space: O(V).

Common Approaches

✓ DFS with All Paths

⏱️ Time: O(n!) Space: O(n)

Use DFS to enumerate all paths from source to destination, calculate the total time for each path considering traffic signals, then find the second minimum time.

Modified BFS (Dijkstra-like)

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

Modified BFS that tracks the best and second-best arrival time at each vertex. Uses a priority queue to process vertices in order of arrival time, considering traffic light delays.

DFS with All Paths — Algorithm Steps

Build adjacency list from edges
Use DFS to explore all paths from 1 to n
For each path, calculate total time considering traffic light delays
Track all unique times and return second minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

DFS Exploration

Recursively explore all paths

Calculate Times

Compute total time for each path considering traffic signals

Code -

solution.c — C

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

#define MAX_N 10005
#define MAX_EDGES 20005
#define MAX_QUEUE 100000
#define INF 1000000000

static int graph[MAX_N][MAX_N];
static int degree[MAX_N];
static int dist[MAX_N][2]; // [node][0] = shortest, [node][1] = second shortest

typedef struct {
    int time;
    int node;
} State;

static State pq[MAX_QUEUE];
static int pq_size = 0;

void push(int time, int node) {
    pq[pq_size].time = time;
    pq[pq_size].node = node;
    pq_size++;
    
    // Bubble up
    int i = pq_size - 1;
    while (i > 0) {
        int parent = (i - 1) / 2;
        if (pq[i].time >= pq[parent].time) break;
        
        State temp = pq[i];
        pq[i] = pq[parent];
        pq[parent] = temp;
        i = parent;
    }
}

State pop() {
    State result = pq[0];
    pq_size--;
    
    if (pq_size > 0) {
        pq[0] = pq[pq_size];
        
        // Bubble down
        int i = 0;
        while (1) {
            int left = 2 * i + 1;
            int right = 2 * i + 2;
            int smallest = i;
            
            if (left < pq_size && pq[left].time < pq[smallest].time) {
                smallest = left;
            }
            if (right < pq_size && pq[right].time < pq[smallest].time) {
                smallest = right;
            }
            
            if (smallest == i) break;
            
            State temp = pq[i];
            pq[i] = pq[smallest];
            pq[smallest] = temp;
            i = smallest;
        }
    }
    
    return result;
}

int isEmpty() {
    return pq_size == 0;
}

int solution(int n, int edges[][2], int edge_count, int time, int change) {
    // Initialize
    memset(degree, 0, sizeof(degree));
    pq_size = 0;
    
    for (int i = 1; i <= n; i++) {
        dist[i][0] = INF;
        dist[i][1] = INF;
    }
    dist[1][0] = 0;
    
    // Build graph
    for (int i = 0; i < edge_count; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][degree[u]++] = v;
        graph[v][degree[v]++] = u;
    }
    
    // Dijkstra-like algorithm
    push(0, 1);
    
    while (!isEmpty()) {
        State curr = pop();
        int currTime = curr.time;
        int node = curr.node;
        
        // If this time is worse than our second best, skip
        if (currTime > dist[node][1]) {
            continue;
        }
        
        // Explore neighbors
        for (int i = 0; i < degree[node]; i++) {
            int neighbor = graph[node][i];
            
            // Calculate departure time considering traffic light
            // We can only leave when light is green
            int cycle = currTime / change;
            int departureTime;
            if (cycle % 2 == 1) { // Currently red, wait for next green
                departureTime = (cycle + 1) * change;
            } else { // Currently green, can leave immediately
                departureTime = currTime;
            }
            
            int arrivalTime = departureTime + time;
            
            // Update shortest and second shortest times
            if (arrivalTime < dist[neighbor][0]) {
                dist[neighbor][1] = dist[neighbor][0];
                dist[neighbor][0] = arrivalTime;
                push(arrivalTime, neighbor);
            } else if (arrivalTime < dist[neighbor][1] && arrivalTime != dist[neighbor][0]) {
                dist[neighbor][1] = arrivalTime;
                push(arrivalTime, neighbor);
            }
        }
    }
    
    return dist[n][1];
}

int parseEdges(char* str, int edges[][2]) {
    if (strcmp(str, "[]") == 0) return 0;
    
    int count = 0;
    int i = 0;
    int len = strlen(str);
    
    while (i < len) {
        if (str[i] == '[' && i > 0) { // Skip the first '[' of the main array
            i++; // Skip '['
            
            // Parse first number
            int u = 0;
            while (i < len && str[i] >= '0' && str[i] <= '9') {
                u = u * 10 + (str[i] - '0');
                i++;
            }
            
            // Skip comma and spaces
            while (i < len && (str[i] == ',' || str[i] == ' ')) i++;
            
            // Parse second number
            int v = 0;
            while (i < len && str[i] >= '0' && str[i] <= '9') {
                v = v * 10 + (str[i] - '0');
                i++;
            }
            
            edges[count][0] = u;
            edges[count][1] = v;
            count++;
            
            // Skip to next edge
            while (i < len && str[i] != '[' && str[i] != ']') i++;
            if (i < len && str[i] == ']') i++;
        } else {
            i++;
        }
    }
    
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char edges_str[10000];
    scanf("%s", edges_str);
    
    int time, change;
    scanf("%d %d", &time, &change);
    
    static int edges[MAX_EDGES][2];
    int edge_count = parseEdges(edges_str, edges);
    
    int result = solution(n, edges, edge_count, time, change);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case, explores all possible permutations of vertices as paths

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth and path storage

✓ Linear Space

23.5K Views

Medium Frequency

~35 min Avg. Time

890 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

DFS with All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler