Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum Number of Platforms Required for a Railway/Bus Station | Set 2 (Set based approach)

  • Difficulty Level : Medium
  • Last Updated : 26 Apr, 2022

Given arrival and departure times of all trains that reach a railway station, 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
There are at-most three trains at a time 
(time between 11:00 to 11:20)

We have already discussed its simple and sorting based solutions in below post. 
Minimum Number of Platforms Required for a Railway/Bus Station.
In this post, we are inserting all the arrival and departure times in a multiset. The first value of element in multiset tells the arrival/departure time and second value tells whether it’s arrival or departure represented by ‘a’ or ‘d’ respectively. 
If its arrival then do increment by 1 otherwise decrease value by 1. If we are taking the input from STDIN then we can directly insert the times in the multiset and no need to store the times in the array. 

C++




// C++ program to find minimum number of platforms
// required on a railway station
#include <bits/stdc++.h>
using namespace std;
 
int findPlatform(int arr[], int dep[], int n)
{
    // Insert all the times (arr. and dep.)
    // in the multiset.
    multiset<pair<int, char> > order;
    for (int i = 0; i < n; i++) {
 
        // If its arrival then second value
        // of pair is 'a' else 'd'
        order.insert(make_pair(arr[i], 'a'));
        order.insert(make_pair(dep[i], 'd'));
    }
 
    int result = 0;
    int plat_needed = 0;
 
    // Start iterating the multiset.
    for (auto it : order) {
 
        // If its 'a' then add 1 to plat_needed
        // else minus 1 from plat_needed.
        if (it.second == 'a')
            plat_needed++;
        else
            plat_needed--;
 
        if (plat_needed > result)
            result = plat_needed;
    }
    return result;
}
 
// Driver code
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;
}
Java



// Java program to find minimum number
// of platforms required on a railway station
import java.io.*;
import java.util.*;
 
class pair
{
    int first;
    char second;
     
    pair(int key1, char key2)
    {
        this.first = key1;
        this.second = key2;
    }
}
 
class GFG{
     
public static int findPlatform(int arr[], int dep[],
                               int n)
{
     
    // Insert all the times (arr. and dep.)
    // in the ArrayList of pairs.
    ArrayList<pair> order = new ArrayList<>();
    for(int i = 0; i < n; i++)
    {
        order.add(new pair(arr[i], 'a'));
        order.add(new pair(dep[i], 'd'));
    }
 
    // Custom sort order ArrayList, first
    // by time than by arrival or departure
    Collections.sort(order, new Comparator<pair>()
    {
        public int compare(pair p1, pair p2)
        {
            if (p1.first == p2.first)
                return new Character(p1.second)
                    .compareTo(
                        new Character(p2.second));
                         
            return p1.first - p2.first;
        }
    });
     
    int result = 1;
    int plat_needed = 0;
     
    for(int i = 0; i < order.size(); i++)
    {
        pair p = order.get(i);
         
        // If its 'a' then add 1 to plat_needed
        // else minus 1 from plat_needed.
        if (p.second == 'a')
            plat_needed++;
        else
            plat_needed--;
             
        if (plat_needed > result)
            result = plat_needed;
    }
    return result;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 900, 940, 950, 1100, 1500, 1800 };
    int dep[] = { 910, 1200, 1120, 1130, 1900, 2000 };
    int n = 6;
     
    System.out.println("Minimum Number of " +
                       "Platforms Required = " +
                       findPlatform(arr, dep, n));
}
}
 
// This code is contributed by RohitOberoi
Python3



# Python3 program to find minimum number
# of platforms required on a railway station
def findPlatform(arr, dep, n):
     
    # Inserting all the arr. and dep. times
    # in the array times
    times = []
    for i in range(n):
        times.append([dep[i], 'd'])
        times.append([arr[i], 'a'])
         
    # Sort the array
    times = sorted(times, key = lambda x: x[1])
    times = sorted(times, key = lambda x: x[0])
     
    result, plat_needed = 0, 0
 
    for i in range(2 * n):
         
        # If its 'a' then add 1 to plat_needed
        # else minus 1 from plat_needed.
        if times[i][1] == 'a':
            plat_needed += 1
            result = max(plat_needed, result)
        else:
            plat_needed -= 1
     
    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 Tharun Reddy
C#



// C# program to find minimum number
// of platforms required on a railway station
using System;
using System.Collections.Generic;
 
public class pair {
  public int first;
  public char second;
 
  public pair(int key1, char key2) {
    this.first = key1;
    this.second = key2;
  }
}
 
public class GFG {
 
  public static int findPlatform(int []arr, int []dep, int n) {
 
    // Insert all the times (arr. and dep.)
    // in the List of pairs.
    List<pair> order = new List<pair>();
    for (int i = 0; i < n; i++) {
      order.Add(new pair(arr[i], 'a'));
      order.Add(new pair(dep[i], 'd'));
    }
 
    // Custom sort order List, first
    // by time than by arrival or departure
    order.Sort((p1,p2)=> p1.first == p2.first? p1.second -
               p2.second:  p1.first - p2.first);
 
    int result = 1;
    int plat_needed = 0;
 
    for (int i = 0; i < order.Count; i++) {
      pair p = order[i];
 
      // If its 'a' then add 1 to plat_needed
      // else minus 1 from plat_needed.
      if (p.second == 'a')
        plat_needed++;
      else
        plat_needed--;
 
      if (plat_needed > result)
        result = plat_needed;
    }
    return result;
  }
 
  // Driver Code
  public static void Main(String[] args) {
    int []arr = { 900, 940, 950, 1100, 1500, 1800 };
    int []dep = { 910, 1200, 1120, 1130, 1900, 2000 };
    int n = 6;
 
    Console.WriteLine("Minimum Number of " +
                      "Platforms Required = " +
                      findPlatform(arr, dep, n));
  }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
    // JavaScript program to find minimum number of platforms
    // required on a railway station
 
    const findPlatform = (arr, dep, n) => {
        // Insert all the times (arr. and dep.)
        // in the multiset.
        let order = new Set();
        for (let i = 0; i < n; i++) {
 
            // If its arrival then second value
            // of pair is 'a' else 'd'
            order.add([arr[i], 'a']);
            order.add([dep[i], 'd']);
        }
 
        let result = 0;
        let plat_needed = 0;
        order = [...order];
 
        order = order.sort((a, b) => a[0] - b[0])
        // Start iterating the multiset.
        for (let it in order) {
 
            // If its 'a' then add 1 to plat_needed
            // else minus 1 from plat_needed.
            if (order[it][1] == 'a')
                plat_needed++;
            else
                plat_needed--;
 
            if (plat_needed > result)
                result = plat_needed;
 
        }
        return result;
    }
 
    // Driver code
 
    let arr = [900, 940, 950, 1100, 1500, 1800];
    let dep = [910, 1200, 1120, 1130, 1900, 2000];
    let n = arr.length;
    document.write(`Minimum Number of Platforms Required = ${findPlatform(arr, dep, n)}`);
 
// This code is contributed by rakeshsahni
 
</script>
Output
Minimum Number of Platforms Required = 3
Complexity Analysis:  
  • Time Complexity: O( N* LogN).
           Since we are inserting into multiset and it maintain elements in sorted order. So N insert operations in multiset requires N*LogN time complexity. 
  • Space Complexity: O(N).  
           We are using multiset which will have 2*N elements .
C++



// C++ program to find minimum number of platforms
// required on a railway station
#include <bits/stdc++.h>
using namespace std;
 
int minPlatform(int arrival[], int departure[], int n)
{
 
    // as time range from 0 to 2359 in 24 hour clock,
    // we declare an array for values from 0 to 2360
    int platform[2361] = {0};
    int requiredPlatform = 1;
    for (int i = 0; i < n; i++) {
 
        // increment the platforms for arrival
        ++platform[arrival[i]];
 
         // once train departs we decrease the platform count
        --platform[departure[i] + 1];
    }
 
    // We are running loop till 2361 because maximum time value
    // in a day can be 23:60
    for (int i = 1; i < 2361; i++) {
 
        // taking cumulative sum of platform give us required
        // number of platform for every minute
        platform[i] = platform[i] + platform[i - 1];
        requiredPlatform = max(requiredPlatform, platform[i]);
    }
    return requiredPlatform;
}
 
// Driver code
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 = "
         << minPlatform(arr, dep, n);
    return 0;
}
Java



// Java program to find minimum number
// of platforms required on a railway
// station
import java.util.*;
import java.lang.*;
 
class GFG{
 
static int minPlatform(int arrival[],
                       int departure[],
                       int n)
{
     
    // As time range from 0 to 2359 in
    // 24 hour clock, we declare an array
    // for values from 0 to 2360
    int[] platform = new int[2361];
    int requiredPlatform = 1;
     
    for(int i = 0; i < n; i++)
    {
         
        // Increment the platforms for arrival
        ++platform[arrival[i]];
 
         // Once train departs we decrease
         // the platform count
        --platform[departure[i] + 1];
    }
     
    // We are running loop till 2361 because
    // maximum time value in a day can be 23:60
    for(int i = 1; i < 2361; i++)
    {
         
        // Taking cumulative sum of platform
        // give us required number of
        // platform for every minute
        platform[i] = platform[i] +
                      platform[i - 1];
        requiredPlatform = Math.max(requiredPlatform,
                                    platform[i]);
    }
    return requiredPlatform;
}
 
// Driver code
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 = " +
                       minPlatform(arr, dep, n));
}
}
 
// This code is contributed by offbeat
Python3



# Python3 program to find minimum number
# of platforms required on a railway station
def minPlatform(arrival, departure, n):
 
    # As time range from 0 to 2359 in
    # 24 hour clock, we declare an array
    # for values from 0 to 2360
    platform = [0] * 2361
    requiredPlatform = 1
     
    for i in range(n):
 
        # Increment the platforms for arrival
        platform[arrival[i]] += 1
 
        # Once train departs we decrease the
        # platform count
        platform[departure[i] + 1] -= 1
 
    # We are running loop till 2361 because
    # maximum time value in a day can be 23:60
    for i in range(1, 2361):
 
        # Taking cumulative sum of
        # platform give us required
        # number of platform for every minute
        platform[i] = platform[i] + platform[i - 1]
        requiredPlatform = max(requiredPlatform,
                               platform[i])
         
    return requiredPlatform
 
# 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 = ",
       minPlatform(arr, dep, n))
 
# This code is contributed by PawanJain1
C#



// C# program to find minimum number
// of platforms required on a railway
// station
using System;
class GFG {
     
    static int minPlatform(int[] arrival, int[] departure, int n)
    {
        // As time range from 0 to 2359 in
        // 24 hour clock, we declare an array
        // for values from 0 to 2360
        int[] platform = new int[2361];
        int requiredPlatform = 1;
          
        for(int i = 0; i < n; i++)
        {
              
            // Increment the platforms for arrival
            ++platform[arrival[i]];
      
             // Once train departs we decrease
             // the platform count
            --platform[departure[i] + 1];
        }
          
        // We are running loop till 2361 because
        // maximum time value in a day can be 23:60
        for(int i = 1; i < 2361; i++)
        {
              
            // Taking cumulative sum of platform
            // give us required number of
            // platform for every minute
            platform[i] = platform[i] +
                          platform[i - 1];
            requiredPlatform = Math.Max(requiredPlatform,
                                        platform[i]);
        }
        return requiredPlatform;
    }
 
  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 = " +
                       minPlatform(arr, dep, n));
  }
}
 
// This code is contributed by divyesh072019.
Javascript



<script>
 
        // JavaScript program for the above approach
 
        function minPlatform(arrival, departure, n) {
 
            // as time range from 0 to 2359 in 24 hour clock,
            // we declare an array for values from 0 to 2360
            let platform = new Array(2361).fill(0);
            let requiredPlatform = 1;
            for (let i = 0; i < n; i++) {
 
                // increment the platforms for arrival
                ++platform[arrival[i]];
 
                // once train departs we
                // decrease the platform count
                --platform[departure[i] + 1];
            }
 
            // We are running loop till 2361
            // because maximum time value
            // in a day can be 23:60
            for (let i = 1; i < 2361; i++) {
 
                // taking cumulative sum of
                // platform give us required
                // number of platform for every minute
                platform[i] =
                platform[i] + platform[i - 1];
                 
                requiredPlatform =
                Math.max(requiredPlatform, platform[i]);
            }
            return requiredPlatform;
        }
 
        // Driver code
 
        let arr = [900, 940, 950, 1100, 1500, 1800];
        let dep = [910, 1200, 1120, 1130, 1900, 2000];
        let n = arr.length;
        document.write("Minimum Number of Platforms Required = "
            + minPlatform(arr, dep, n));
 
 
    // This code is contributed by Potta Lokesh
 
    </script>
Output
Minimum Number of Platforms Required = 3
Complexity Analysis:  
  • Time Complexity: O(N).
  • Space Complexity: O(1).  
          
This article is contributed by Jatin Goyal and Abhinav Kumar Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

My Personal Notes
arrow_drop_up
Previous
Directi Interview | Set 1
Next

Multimap in C++ Standard Template Library (STL)
Recommended Articles
Page :
Minimum total cost incurred to reach the last station
01, Feb 18
Count ways to reach the Nth station
26, May 21
Minimum increment or decrement required to sort the array | Top-down Approach
09, Apr 20
Minimum number of candies required to distribute among children based on given conditions
11, Jun 21
Minimum moves required to type a word in QWERTY based keyboard
19, Aug 20
Minimum steps required to reduce all array elements to 1 based on given steps
16, Nov 21
Sort the strings based on the numbers of matchsticks required to represent them
06, May 20
Sort numbers based on count of letters required to represent them in words
10, Jun 20
Minimum number of coins needed to remove all the elements of the array based on given rules
10, Sep 21
Minimum number of swaps required to sort an array of first N number
15, Feb 20
Minimum number of distinct powers of 2 required to express a given binary number
18, Jul 20
Minimum and maximum number of digits required to be removed to make a given number divisible by 3
02, Dec 20
Minimum number of jumps required to sort numbers placed on a number line
01, Jun 21
Minimum deletions from front or back required to remove maximum and minimum from Array
21, Oct 21
Minimum number of swaps required to sort an array | Set 2
01, Oct 18
Minimum number of array indices required to be selected to make the sum of a set greater than another
30, Jul 21
Minimum number of jumps required to Sort the given Array in ascending order| Set-2
27, Dec 21
Add 1 to number represented as array | Recursive Approach
05, Dec 17
Minimum sum of array elements based on given Criteria
14, Aug 19
Minimum steps to reach a given index in the Array based on given conditions
10, Sep 21
Merge K sorted arrays | Set 3 ( Using Divide and Conquer Approach )
11, Feb 19
Sort elements by frequency | Set 4 (Efficient approach using hash)
20, Sep 17
Minimum number of swaps required for arranging pairs adjacent to each other
16, Aug 15
Minimum number of swaps required to sort an array
24, Nov 16
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!