2332. The Latest Time to Catch a Bus LeetCode Solution
In this guide, you will get 2332. The Latest Time to Catch a Bus LeetCode Solution with the best time and space complexity. The solution to The Latest Time to Catch a Bus problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.
Problem Statement of The Latest Time to Catch a Bus
You are given a 0-indexed integer array buses of length n, where buses[i] represents the departure time of the ith bus. You are also given a 0-indexed integer array passengers of length m, where passengers[j] represents the arrival time of the jth passenger. All bus departure times are unique. All passenger arrival times are unique.
You are given an integer capacity, which represents the maximum number of passengers that can get on each bus.
When a passenger arrives, they will wait in line for the next available bus. You can get on a bus that departs at x minutes if you arrive at y minutes where y <= x, and the bus is not full. Passengers with the earliest arrival times get on the bus first.
More formally when a bus arrives, either:
If capacity or fewer passengers are waiting for a bus, they will all get on the bus, or
The capacity passengers with the earliest arrival times will get on the bus.
Return the latest time you may arrive at the bus station to catch a bus. You cannot arrive at the same time as another passenger.
Note: The arrays buses and passengers are not necessarily sorted.
Example 1:
Input: buses = [10,20], passengers = [2,17,18,19], capacity = 2
Output: 16
Explanation: Suppose you arrive at time 16.
At time 10, the first bus departs with the 0th passenger.
At time 20, the second bus departs with you and the 1st passenger.
Note that you may not arrive at the same time as another passenger, which is why you must arrive before the 1st passenger to catch the bus.
Example 2:
Input: buses = [20,30,10], passengers = [19,13,26,4,25,11,21], capacity = 2
Output: 20
Explanation: Suppose you arrive at time 20.
At time 10, the first bus departs with the 3rd passenger.
At time 20, the second bus departs with the 5th and 1st passengers.
At time 30, the third bus departs with the 0th passenger and you.
Notice if you had arrived any later, then the 6th passenger would have taken your seat on the third bus.
Constraints:
n == buses.length
m == passengers.length
1 <= n, m, capacity <= 105
2 <= buses[i], passengers[i] <= 109
Each element in buses is unique.
Each element in passengers is unique.
Complexity Analysis
Time Complexity: O(\texttt{sort}(\texttt{buses}) + \texttt{sort}(\texttt{passengers}))
Space Complexity: O(\texttt{sort}(\texttt{buses}) + \texttt{sort}(\texttt{passengers}))
2332. The Latest Time to Catch a Bus LeetCode Solution in C++
class Solution {
public:
int latestTimeCatchTheBus(vector<int>& buses, vector<int>& passengers,
int capacity) {
ranges::sort(buses);
ranges::sort(passengers);
if (passengers.front() > buses.back())
return buses.back();
int ans = passengers[0] - 1;
int i = 0; // buses' index
int j = 0; // passengers' index
while (i < buses.size()) {
// Greedily make passengers catch `buses[i]`.
int arrived = 0;
while (arrived < capacity && j < passengers.size() &&
passengers[j] <= buses[i]) {
if (j > 0 && passengers[j] != passengers[j - 1] + 1)
ans = passengers[j] - 1;
++j;
++arrived;
}
// There's room for `buses[i]` to carry a passenger arriving at
// `buses[i]`.
if (arrived < capacity && j > 0 && passengers[j - 1] != buses[i])
ans = buses[i];
++i;
}
return ans;
}
}; /* code provided by PROGIEZ */
2332. The Latest Time to Catch a Bus LeetCode Solution in Java
class Solution {
public int latestTimeCatchTheBus(int[] buses, int[] passengers, int capacity) {
Arrays.sort(buses);
Arrays.sort(passengers);
if (passengers[0] > buses[buses.length - 1])
return buses[buses.length - 1];
int ans = passengers[0] - 1;
int i = 0; // buses' index
int j = 0; // passengers' index
while (i < buses.length) {
// Greedily make passengers catch `buses[i]`.
int arrived = 0;
while (arrived < capacity && j < passengers.length && passengers[j] <= buses[i]) {
if (j > 0 && passengers[j] != passengers[j - 1] + 1)
ans = passengers[j] - 1;
++j;
++arrived;
}
// There's room for `buses[i]` to carry a passenger arriving at the
// `buses[i]`.
if (arrived < capacity && j > 0 && passengers[j - 1] != buses[i])
ans = buses[i];
++i;
}
return ans;
}
} // code provided by PROGIEZ
2332. The Latest Time to Catch a Bus LeetCode Solution in Python
class Solution:
def latestTimeCatchTheBus(
self,
buses: list[int],
passengers: list[int],
capacity: int,
) -> int:
buses.sort()
passengers.sort()
if passengers[0] > buses[-1]:
return buses[-1]
ans = passengers[0] - 1
i = 0 # buses' index
j = 0 # passengers' index
while i < len(buses):
# Greedily make passengers catch `buses[i]`.
arrived = 0
while arrived < capacity and j < len(passengers) and passengers[j] <= buses[i]:
if j > 0 and passengers[j] != passengers[j - 1] + 1:
ans = passengers[j] - 1
j += 1
arrived += 1
# There's room for `buses[i]` to carry a passenger arriving at the
# `buses[i]`.
if arrived < capacity and j > 0 and passengers[j - 1] != buses[i]:
ans = buses[i]
i += 1
return ans # code by PROGIEZ
