Minimize the Maximum Waiting Time at Synchronized Traffic Lights - Video Solutions
Minimize the Maximum Waiting Time at Synchronized Traffic Lights | LeetCode 4025 | Developer Coder
Minimize the Maximum Waiting Time at Synchronized Traffic Lights - Video Solution
Watch 6 video solutions for Minimize the Maximum Waiting Time at Synchronized Traffic Lights, a medium level problem involving Array, Greedy. This walkthrough by Developer Coder has 75 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
Problem Statement
You are given an integer period and an integer array lights, where lights[i] is the duration, in seconds, of the green phase of the ith traffic light.
At time 0, every traffic light starts at the beginning of its green phase. Their cycles are synchronized: every traffic light starts a new cycle at the same time, and every cycle lasts exactly period seconds. Therefore, the red phase of the ith traffic light lasts for period - lights[i] seconds.
You are also given an integer array arrivalTime, where arrivalTime[j] is the arrival time, in seconds, of the jth car.
Each car must be assigned to exactly one traffic light. Multiple cars may be assigned to the same traffic light. Any number of cars may cross the same traffic light simultaneously while it is green. Cars do not block or delay one another.
For a car j assigned to the ith traffic light, let r = arrivalTime[j] % period. If r < lights[i], its waiting time is 0. Otherwise, its waiting time is period - r.
The penalty of an assignment is the maximum waiting time among all cars.
Return an integer denoting the minimum possible penalty.
Example 1:
Input: period = 8, lights = [2,3], arrivalTime = [2,5,8,11]
Output: 5
Explanation:
One optimal solution is:
- Assign
arrivalTime[0]to the traffic light withlights[1] = 3. Here,r = 2 % 8 = 2. Since2 < 3, the waiting time is 0. - Assign
arrivalTime[1]to the traffic light withlights[0] = 2. Here,r = 5 % 8 = 5. Since5 >= 2, the waiting time is8 - 5 = 3. - Assign
arrivalTime[2]to the traffic light withlights[0] = 2. Here,r = 8 % 8 = 0. Since0 < 2, the waiting time is 0. - Assign
arrivalTime[3]to the traffic light withlights[0] = 2. Here,r = 11 % 8 = 3. Since3 >= 2, the waiting time is8 - 3 = 5.
The penalty of this assignment is 5, which is the minimum possible. Other optimal assignments may exist.
Example 2:
Input: period = 10, lights = [3,6,8], arrivalTime = [4,9,15]
Output: 1
Explanation:
One optimal solution is:
- Assign
arrivalTime[0]to the traffic light withlights[2] = 8. Here,r = 4 % 10 = 4. Since4 < 8, the waiting time is 0. - Assign
arrivalTime[1]to the traffic light withlights[2] = 8. Here,r = 9 % 10 = 9. Since9 >= 8, the waiting time is10 - 9 = 1. - Assign
arrivalTime[2]to the traffic light withlights[2] = 8. Here,r = 15 % 10 = 5. Since5 < 8, the waiting time is 0.
The penalty of this assignment is 1, which is the minimum possible.
Example 3:
Input: period = 5, lights = [2], arrivalTime = [2,3,4,5,6]
Output: 3
Explanation:
One optimal solution is:
- Assign
arrivalTime[0]to the traffic light withlights[0] = 2. Here,r = 2 % 5 = 2. Since2 >= 2, the waiting time is5 - 2 = 3. - Assign
arrivalTime[1]to the traffic light withlights[0] = 2. Here,r = 3 % 5 = 3. Since3 >= 2, the waiting time is5 - 3 = 2. - Assign
arrivalTime[2]to the traffic light withlights[0] = 2. Here,r = 4 % 5 = 4. Since4 >= 2, the waiting time is5 - 4 = 1. - Assign
arrivalTime[3]to the traffic light withlights[0] = 2. Here,r = 5 % 5 = 0. Since0 < 2, the waiting time is 0. - Assign
arrivalTime[4]to the traffic light withlights[0] = 2. Here,r = 6 % 5 = 1. Since1 < 2, the waiting time is 0.
The penalty of this assignment is 3, which is the minimum possible.
Constraints:
2 <= period <= 1091 <= lights.length <= 1041 <= lights[i] <= period - 11 <= arrivalTime.length <= 1051 <= arrivalTime[i] <= 109
Approach Overview
Problem Overview: You have an array of cars arriving at synchronized traffic lights, and you need to minimize the maximum waiting time any car experiences. The lights cycle through green and red phases, and you can control the green phase duration to achieve this.
Approach 1: Brute Force (O(n^2) Time, O(1) Space)
Try every possible green phase duration from 1 to the maximum arrival time. For each candidate, simulate the waiting time for each car by iterating through the array and calculating when each car can pass. Track the maximum waiting time and choose the candidate that minimizes it. This approach is straightforward but inefficient for large inputs because it repeats the simulation for each candidate. Use it only when the input size is very small or as a baseline to verify correctness.
Approach 2: Greedy (O(n) Time, O(1) Space) - Optimal
The key insight is that the optimal green phase duration is simply the maximum arrival time among all cars. Why? Because if you set the green phase to that value, every car arrives during a green phase and waits zero time. Any shorter green phase would force some cars to wait for the next cycle, increasing the maximum waiting time. So you just iterate through the array once, track the maximum arrival time, and return it. This is a classic greedy solution that exploits the problem's structure directly.
Recommended for interviews: Interviewers expect the greedy solution because it shows you can identify the underlying pattern rather than overcomplicating it. The brute force demonstrates you understand the problem, but the optimal solution proves you can think critically about constraints and derive a simple answer. Always start by explaining the brute force to show your reasoning, then pivot to the greedy insight.
Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Brute Force | O(n^2) | O(1) | Small inputs or as a baseline for testing |
| Greedy (Optimal) | O(n) | O(1) | General case, expected in interviews |