Minimum Number of Platforms Required for a Railway/Bus Station
Given arrival and departure times of all trains that reach a railway station, the task is to find the minimum number of platforms required for the railway station so that no train waits.
We are given two arrays which represent arrival and departure times of trains that stop.
Examples:
Input: arr[] = {9:00, 9:40, 9:50, 11:00, 15:00, 18:00}
dep[] = {9:10, 12:00, 11:20, 11:30, 19:00, 20:00}
Output: 3
Explantion: There are atmost three trains at a time (time between 11:00 to 11:20)Input: arr[] = {9:00, 9:40}
dep[] = {9:10, 12:00}
Output: 1
Explantion: Only one platform is needed.
Simple Solution:
 Approach: The idea is to take every interval one by one and find the number of intervals that overlap with it. Keep track of the maximum number of intervals that overlap with an interval. Finally, return the maximum value.

Algorithm:
 Run two nested loops the outer loop from start to end and inner loop from i+1 to end.
 For every iteration of outer loop find the count of intervals that intersect with the current interval.
 Update the answer with maximum count of overlap in each iteration of outer loop.
 Print the answer.

Implementation:
// Program to find minimum number of platforms
// required on a railway station
#include <algorithm>
#include <iostream>
using
namespace
std;
// Returns minimum number of platforms reqquired
int
findPlatform(
int
arr[],
int
dep[],
int
n)
{
// plat_needed indicates number of platforms
// needed at a time
int
plat_needed = 1, result = 1;
int
i = 1, j = 0;
// run a nested loop to find overlap
for
(
int
i = 0; i < n; i++) {
// minimum platform
plat_needed = 1;
for
(
int
j = i + 1; j < n; j++) {
// check for overlap
if
((arr[i] >= arr[j] && arr[i] <= dep[j])  (arr[j] >= arr[i] && arr[j] <= dep[i]))
plat_needed++;
}
// update result
result = max(result, plat_needed);
}
return
result;
}
// Driver program to test methods of graph class
int
main()
{
int
arr[] = { 900, 940, 950, 1100, 1500, 1800 };
int
dep[] = { 910, 1200, 1120, 1130, 1900, 2000 };
int
n =
sizeof
(arr) /
sizeof
(arr[0]);
cout <<
"Minimum Number of Platforms Required = "
<< findPlatform(arr, dep, n);
return
0;
}
chevron_rightfilter_noneOutput:
Minimum Number of Platforms Required = 3

Complexity Analysis:
 Time Complexity: O(n^2).
Two nested loops traverse the array, so the time complexity is O(n^2).  Space Complexity: O(1).
As no extra space is required.
 Time Complexity: O(n^2).
Efficient Solution:
 Approach: The idea is to consider all events in sorted order. Once the events are in sorted order, trace the number of trains at any time keeping track of trains that have arrived, but not departed.
For example consider the above example.
arr[] = {9:00, 9:40, 9:50, 11:00, 15:00, 18:00} dep[] = {9:10, 12:00, 11:20, 11:30, 19:00, 20:00} All events are sorted by time. Total platforms at any time can be obtained by subtracting total departures from total arrivals by that time. Time Event Type Total Platforms Needed at this Time 9:00 Arrival 1 9:10 Departure 0 9:40 Arrival 1 9:50 Arrival 2 11:00 Arrival 3 11:20 Departure 2 11:30 Departure 1 12:00 Departure 0 15:00 Arrival 1 18:00 Arrival 2 19:00 Departure 1 20:00 Departure 0 Minimum Platforms needed on railway station = Maximum platforms needed at any time = 3
Note: This approach assumes that trains are arriving and departing on the same date.

Algorithm:
 Sort the arrival and departure time of trains.
 Create two pointers i=0, and j=0 and a variable to store ans and current count plat
 Run a loop while i<n and j<n and compare the ith element of arrival array and jth element of departure array.
 if the arrival time is less than or equal to departure then one more platform is needed so increase the count, i.e. plat++ and increment i
 Else if the arrival time greater than departure then one less platform is needed so decrease the count, i.e. plat++ and increment j
 Update the ans, i.e ans = max(ans, plat).

Implementation: This doesn’t create a single sorted list of all events, rather it individually sorts arr[] and dep[] arrays, and then uses merge process of merge sort to process them together as a single sorted array.
C++
// Program to find minimum number of platforms
// required on a railway station
#include <algorithm>
#include <iostream>
using
namespace
std;
// Returns minimum number of platforms reqquired
int
findPlatform(
int
arr[],
int
dep[],
int
n)
{
// Sort arrival and departure arrays
sort(arr, arr + n);
sort(dep, dep + n);
// plat_needed indicates number of platforms
// needed at a time
int
plat_needed = 1, result = 1;
int
i = 1, j = 0;
// Similar to merge in merge sort to process
// all events in sorted order
while
(i < n && j < n) {
// If next event in sorted order is arrival,
// increment count of platforms needed
if
(arr[i] <= dep[j]) {
plat_needed++;
i++;
}
// Else decrement count of platforms needed
else
if
(arr[i] > dep[j]) {
plat_needed;
j++;
}
// Update result if needed
if
(plat_needed > result)
result = plat_needed;
}
return
result;
}
// Driver program to test methods of graph class
int
main()
{
int
arr[] = { 900, 940, 950, 1100, 1500, 1800 };
int
dep[] = { 910, 1200, 1120, 1130, 1900, 2000 };
int
n =
sizeof
(arr) /
sizeof
(arr[0]);
cout <<
"Minimum Number of Platforms Required = "
<< findPlatform(arr, dep, n);
return
0;
}
chevron_rightfilter_noneJava
// Program to find minimum number of platforms
import
java.util.*;
class
GFG {
// Returns minimum number of platforms reqquired
static
int
findPlatform(
int
arr[],
int
dep[],
int
n)
{
// Sort arrival and departure arrays
Arrays.sort(arr);
Arrays.sort(dep);
// plat_needed indicates number of platforms
// needed at a time
int
plat_needed =
1
, result =
1
;
int
i =
1
, j =
0
;
// Similar to merge in merge sort to process
// all events in sorted order
while
(i < n && j < n) {
// If next event in sorted order is arrival,
// increment count of platforms needed
if
(arr[i] <= dep[j]) {
plat_needed++;
i++;
}
// Else decrement count of platforms needed
else
if
(arr[i] > dep[j]) {
plat_needed;
j++;
}
// Update result if needed
if
(plat_needed > result)
result = plat_needed;
}
return
result;
}
// Driver program to test methods of graph class
public
static
void
main(String[] args)
{
int
arr[] = {
900
,
940
,
950
,
1100
,
1500
,
1800
};
int
dep[] = {
910
,
1200
,
1120
,
1130
,
1900
,
2000
};
int
n = arr.length;
System.out.println(
"Minimum Number of Platforms Required = "
+ findPlatform(arr, dep, n));
}
}
chevron_rightfilter_nonePython3
# Program to find minimum
# number of platforms
# required on a railway
# station
# Returns minimum number
# of platforms reqquired
def
findPlatform(arr, dep, n):
# Sort arrival and
# departure arrays
arr.sort()
dep.sort()
# plat_needed indicates
# number of platforms
# needed at a time
plat_needed
=
1
result
=
1
i
=
1
j
=
0
# Similar to merge in
# merge sort to process
# all events in sorted order
while
(i < n
and
j < n):
# If next event in sorted
# order is arrival,
# increment count of
# platforms needed
if
(arr[i] <
=
dep[j]):
plat_needed
+
=
1
i
+
=
1
# Else decrement count
# of platforms needed
elif
(arr[i] > dep[j]):
plat_needed

=
1
j
+
=
1
# Update result if needed
if
(plat_needed > result):
result
=
plat_needed
return
result
# driver code
arr
=
[
900
,
940
,
950
,
1100
,
1500
,
1800
]
dep
=
[
910
,
1200
,
1120
,
1130
,
1900
,
2000
]
n
=
len
(arr)
print
(
"Minimum Number of Platforms Required = "
,
findPlatform(arr, dep, n))
# This code is contributed
# by Anant Agarwal.
chevron_rightfilter_noneC#
// C# program to find minimum number
// of platforms
using
System;
class
GFG {
// Returns minimum number of platforms
// reqquired
static
int
findPlatform(
int
[] arr,
int
[] dep,
int
n)
{
// Sort arrival and departure arrays
Array.Sort(arr);
Array.Sort(dep);
// plat_needed indicates number of
// platforms needed at a time
int
plat_needed = 1, result = 1;
int
i = 1, j = 0;
// Similar to merge in merge sort
// to process all events in sorted
// order
while
(i < n && j < n) {
// If next event in sorted order
// is arrival, increment count
// of platforms needed
if
(arr[i] <= dep[j]) {
plat_needed++;
i++;
}
// Else decrement count of
// platforms needed
else
if
(arr[i] > dep[j]) {
plat_needed;
j++;
}
// Update result if needed
if
(plat_needed > result)
result = plat_needed;
}
return
result;
}
// Driver program to test methods of
// graph class
public
static
void
Main()
{
int
[] arr = { 900, 940, 950, 1100,
1500, 1800 };
int
[] dep = { 910, 1200, 1120, 1130,
1900, 2000 };
int
n = arr.Length;
Console.Write(
"Minimum Number of "
+
" Platforms Required = "
+ findPlatform(arr, dep, n));
}
}
// This code os contributed by nitin mittal.
chevron_rightfilter_nonePHP
<?php
// PHP Program to find minimum number
// of platforms required on a railway
// station
// Returns minimum number of
// platforms reqquired
function
findPlatform(
$arr
,
$dep
,
$n
)
{
// Sort arrival and
// departure arrays
sort(
$arr
);
sort(
$dep
);
// plat_needed indicates
// number of platforms
// needed at a time
$plat_needed
= 1;
$result
= 1;
$i
= 1;
$j
= 0;
// Similar to merge in
// merge sort to process
// all events in sorted order
while
(
$i
<
$n
and
$j
<
$n
)
{
// If next event in sorted
// order is arrival, increment
// count of platforms needed
if
(
$arr
[
$i
] <=
$dep
[
$j
])
{
$plat_needed
++;
$i
++;
}
// Else decrement count
// of platforms needed
elseif
(
$arr
[
$i
] >
$dep
[
$j
])
{
$plat_needed
;
$j
++;
}
// Update result if needed
if
(
$plat_needed
>
$result
)
$result
=
$plat_needed
;
}
return
$result
;
}
// Driver Code
$arr
=
array
(900, 940, 950, 1100, 1500, 1800);
$dep
=
array
(910, 1200, 1120, 1130, 1900, 2000);
$n
=
count
(
$arr
);
echo
"Minimum Number of Platforms Required = "
, findPlatform(
$arr
,
$dep
,
$n
);
// This code is contributed by anuj_67.
?>
chevron_rightfilter_none
Output:Minimum Number of Platforms Required = 3

Complexity Analysis:
 Time Complexity: O(n Log n).
One traversal of both the array is needed, so the time Complexity is O(n).  Space Complexity: O(1).
As no extra space is required.
 Time Complexity: O(n Log n).
Note: The solution mentioned above uses O(n log n) time complexity and O(1) Space Complexity. There is one more approach to the problem which uses O(n) extra space and O(n) time to solve the problem:
Minimum Number of Platforms Required for a Railway/Bus Station  Set 2 (Mapbased approach)
This article is contributed by Shivam. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a studentfriendly price.
Recommended Posts:
 Minimum total cost incurred to reach the last station
 Minimum number of operations required to reduce N to 1
 Minimum number of days required to complete the work
 Minimum number of subsequences required to convert one string to another
 Minimum number of pairs required to make two strings same
 Minimum number of bottles required to fill K glasses
 Minimum deletions required such that any number X will occur exactly X times
 Minimum number of swaps required to make the string K periodic
 Minimum number of given operations required to reduce the array to 0 element
 Minimum number of operations required to delete all elements of the array
 Minimum number of points required to cover all blocks of a 2D grid
 Minimum number of towers required such that every house is in the range of at least one tower
 Minimum number of colors required to color a Circular Array
 Minimum number of subsequences required to convert one string to another using Greedy Algorithm
 Minimum number of adjacent swaps required to convert a permutation to another permutation by given condition
 Minimum time required to rot all oranges
 Minimum boxes required to carry all gifts
 Minimum concatenation required to get strictly LIS for the given array
 Minimum changes required such that the string satisfies the given condition
 Minimum halls required for class scheduling