Second Minimum Time to Reach Destination - Practice Coding Problems

Second Minimum Time to Reach Destination - Problem

🚦 Navigate Through Traffic Lights to Find the Second Fastest Route

Imagine you're navigating through a city where every intersection has traffic lights that change color simultaneously every few minutes. You need to find the second minimum time to travel from intersection 1 to intersection n.

The city is represented as a bi-directional graph where:

Each vertex (1 to n) represents an intersection
Each edge represents a road that takes exactly time minutes to traverse
Every intersection has a traffic signal that alternates between green and red every change minutes
All signals start green and change simultaneously

Traffic Rules:

🟢 You can enter an intersection at any time
🟢 You can only leave an intersection when the light is green
🔴 If you arrive at an intersection when the light is red, you must wait
⚠️ You cannot wait at an intersection if the light is green (you must leave immediately)

Your goal is to find the second minimum time to reach destination n from source 1. The second minimum is defined as the smallest time that is strictly larger than the minimum time.

Input & Output

example_1.py — Basic Graph

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

› Output: 13

💡 Note: The shortest path is 1→4→5 taking 9 minutes. The second shortest path is 1→3→4→5 taking 13 minutes (with potential traffic light delays).

example_2.py — Simple Path

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

› Output: 11

💡 Note: Only one direct path 1→2. The shortest time is 3 minutes. To get the second shortest, we must wait for a red light cycle, giving us 3 + 2 + 3 + 3 = 11 minutes.

example_3.py — Multiple Paths

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

› Output: 8

💡 Note: Shortest path 1→3→4 takes 4 minutes. Second shortest 1→2→3→4 takes 6 minutes. With traffic lights, the second shortest becomes 8 minutes.

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
No duplicate edges and graph is connected
1 ≤ time, change ≤ 10³

Visualization

Tap to expand

Understanding the Visualization

Initialize Journey

Start at intersection 1 with all traffic lights green, ready to explore optimal routes

Calculate Timing

At each intersection, check if traffic light is green (go) or red (wait for next cycle)

Track Best Routes

Maintain the fastest and second-fastest arrival time to each intersection

BFS Exploration

Use breadth-first search to systematically explore all possible paths

Find Second Best

Return the second minimum time to reach the destination

Key Takeaway

🎯 Key Insight: Use modified BFS to efficiently find the second minimum path while properly handling traffic light constraints by tracking two arrival times per vertex.

Asked in

G Google 35 a Amazon 28 f Meta 22 Apple 18 ⊞ Microsoft 15

The optimal solution uses a modified BFS that tracks both the shortest and second-shortest arrival times for each vertex. The key insight is handling traffic light timing by calculating departure times based on red/green cycles, and using BFS to efficiently explore paths while avoiding infinite loops by limiting each vertex to at most two visits.

Common Approaches

Approach	Time	Space	Notes
✓ Modified BFS (Optimal)	O(V + E)	O(V + E)	Use BFS to track first and second shortest arrival times to each vertex
Brute Force (DFS All Paths)	O(2^n)	O(n)	Explore all possible paths using DFS and track all arrival times

Modified BFS (Optimal) — Algorithm Steps

Build adjacency list from edges
Initialize arrays to track first and second shortest times for each vertex
Use BFS queue starting from vertex 1 at time 0
For each vertex, calculate departure time based on traffic light state
Add travel time to get arrival time at neighbor
Update first/second shortest times for neighbor if better
Continue until we have both shortest times for destination vertex
Return the second shortest time

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize BFS

Start from vertex 1 with time 0, initialize distance arrays

Process Current Vertex

Calculate departure time based on current traffic light state

Update Neighbors

For each neighbor, update first or second shortest time if better

Add to Queue

Add neighbors with updated times to BFS queue

Return Result

Return second shortest time when destination is reached

Code -

solution.c — C

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

#define MAX_N 10000
#define MAX_QUEUE 100000

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

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int dist1[MAX_N];
int dist2[MAX_N];
State queue[MAX_QUEUE];
int front = 0, rear = 0;

void enqueue(int vertex, int time) {
    queue[rear].vertex = vertex;
    queue[rear].time = time;
    rear++;
}

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

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

int secondMinimumTime(int n, int** edges, int edgesSize, int* edgesColSize, int time, int change) {
    // Initialize
    memset(graphSize, 0, sizeof(graphSize));
    for (int i = 0; i <= n; i++) {
        dist1[i] = -1;
        dist2[i] = -1;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    enqueue(1, 0);
    dist1[1] = 0;
    
    while (!isEmpty()) {
        State current = dequeue();
        int vertex = current.vertex;
        int currTime = current.time;
        
        // Calculate departure time considering traffic light
        int cycles = currTime / change;
        int departureTime;
        if (cycles % 2 == 1) { // Red light
            int waitTime = change - (currTime % change);
            departureTime = currTime + waitTime;
        } else { // Green light
            departureTime = currTime;
        }
        
        int arrivalTime = departureTime + time;
        
        for (int i = 0; i < graphSize[vertex]; i++) {
            int neighbor = graph[vertex][i];
            if (dist1[neighbor] == -1) { // First visit
                dist1[neighbor] = arrivalTime;
                enqueue(neighbor, arrivalTime);
            } else if (dist2[neighbor] == -1 && arrivalTime > dist1[neighbor]) { // Second visit
                dist2[neighbor] = arrivalTime;
                enqueue(neighbor, arrivalTime);
                if (neighbor == n) { // Found second shortest to destination
                    return dist2[n];
                }
            }
        }
    }
    
    return dist2[n];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Each vertex is visited at most twice (for shortest and second shortest), and each edge is traversed at most twice

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list, distance arrays, and BFS queue

✓ Linear Space

67.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

🚦 Navigate Through Traffic Lights to Find the Second Fastest Route

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Modified BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler