 GFG App
Open App Browser
Continue

# Find the Platform at which the given Train arrives

Given a 2D array arr[] consisting of information of N trains where arr[i] is the train number, arr[i] is the arrival time, and arr[i] is the duration of stoppage time. Given another integer F representing the train number, the task is to find the platform number on which the train with train number F arrives according to the following rules:

• Platform numbering starts from 1 and there is an infinite number of platforms.
• The platform which is freed earlier is allocated to the next train.
• If two or more platforms are freed at the same time then the train arrives at the platform with the lowest platform number.
• If two or more trains arriving at the same time, then the train with a smaller train number is allocated first.

Examples:

Input: arr[] = {{112567, 1, 2}, {112563, 3, 3}, {112569, 4, 7}, {112560, 9, 3}}, F = 112569
Output: 1
Explanation:
Below is the order of the arrival of trains:
Train          Platform   Leaving Time
112567        1               4
112563        2               7
112569       1              12
112560       2              13

Therefore, the train with train number 112569 arrives at platform number 1.

Input: arr[] = {{112567, 2, 1}, {112563, 5, 5}, {112569, 7, 3}, {112560, 3, 7}}, F = 112569
Output: 3

Approach: The given problem can be solved by using the priority queue. Follow the steps below to solve this problem:

• Sort the given array arr[] of N trains according to the arrival time of the trains.
• Initialize a priority queue, say PQ of pairs {PlatformNumber, time} that implements the min-heap according to the least departure time. Insert the {platform number, time} i.e., {1, 0} in the priority queue.
• Initialize a HashMap, say M that stores the platform number on which any train arrives.
• Traverse the given array arr[] and perform the following steps:
• Pop the top platform of the PQ and store them in free_platform[].
• If the arrival time of the current train is at least the departure time of the popped platform, then update the departure time of the popped platform as the (sum of the arrival and the stoppage time + 1) and insert the current status of the platform in PQ and the current platform number of the current train in the HashMap M.
• Otherwise, add the new platform entry to the PQ and the current platform number of the current train in the HashMap M.
• After completing the above steps, print the platform number associated with the train number F in the HashMap M.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `// Stores the information for each` `// train as Objects` `class` `Train {` `  ``public``:` `  ``// Stores the train number`   `  ``string train_num;`   `  ``// Stores the arrival time`   `  ``int` `arrival_time;`   `  ``// Stores the stoppage time`   `  ``int` `stoppage_time;`   `  ``// Constructor`   `  ``Train(string train_num, ``int` `arrival_time, ``int` `stoppage_time) {` `    ``this``->train_num = train_num;` `    ``this``->arrival_time = arrival_time;` `    ``this``->stoppage_time = stoppage_time;` `  ``}` `};`   `// custom search comparator` `bool` `sortArrivalTime(Train &o1, Train &o2) {` `  ``if` `(o1.arrival_time == o2.arrival_time) ``return` `o1.train_num < o2.train_num;` `  ``return` `(o1.arrival_time < o2.arrival_time);` `}`   `// Function to find the platform` `// on which train F arrives` `static` `int` `findPlatformOf(vector trains, ``int` `n, string F) {` `  ``// Sort the array arr[] according` `  ``// to the arrival time`   `  ``sort(trains.begin(), trains.end(), sortArrivalTime);`   `  ``// Stores the platforms that` `  ``// is in currently in use` `  ``priority_queue> pq;`     `  ``// Insert the platform number 1` `  ``// with departure time as 0` `  ``vector<``int``> temp = {1, 0};` `  ``pq.push(temp);`   `  ``// Store the platform number` `  ``// on which train arrived` `  ``map schedule;`   `  ``// Traverse the given array` `  ``for` `(``auto` `t : trains) {` `    ``// Pop the top platform of` `    ``// the priority queue` `    ``vector<``int``> free_platform = pq.top();` `    ``pq.pop();`   `    ``// If arrival time of the train` `    ``// >= freeing time of the platform` `    ``if` `(t.arrival_time >= free_platform) {` `      ``// Update the train status` `      ``free_platform = t.arrival_time + t.stoppage_time + 1;` `      ``// Add the current platform` `      ``// to the pq` `      ``pq.push(free_platform);`   `      ``// Add the platform` `      ``// number to the HashMap` `      ``schedule[t.train_num] = free_platform;` `    ``}` `    ``// Otherwise, add a new platform` `    ``// for the current train` `    ``else` `{` `      ``// Update the priority queue` `      ``pq.push(free_platform);`   `      ``// Get the platform number` `      ``int` `platform_num = pq.size() + 1;`   `      ``// Add the platform to` `      ``// the priority queue` `      ``vector<``int``> temp = {platform_num, t.arrival_time + t.stoppage_time + 1};` `      ``pq.push(temp);`   `      ``// Add the platform` `      ``// number to the HashMap` `      ``schedule[t.train_num] = platform_num;` `    ``}` `  ``}`   `  ``// Return the platform on` `  ``// which F train arrived` `  ``return` `schedule[F];` `}`   `// Driver Code` `signed` `main() {` `  ``vector trains;`   `  ``trains.push_back(Train(``"112567"``, 2, 1));` `  ``trains.push_back(Train(``"112569"``, 5, 5));` `  ``trains.push_back(Train(``"112563"``, 5, 3));` `  ``trains.push_back(Train(``"112560"``, 3, 7));` `  ``string F = ``"112563"``;`   `  ``cout << (findPlatformOf(trains, trains.size(), F));` `  ``return` `0;` `}`   `// This code is contributed by sdeadityasharma.`

## Java

 `// Java program for the above approach`   `import` `java.util.*;`   `// Stores the information for each` `// train as Objects` `class` `Train {` `    ``// Stores the train number` `    ``String train_num;`   `    ``// Stores the arrival time` `    ``int` `arrival_time;`   `    ``// Stores the stoppage time` `    ``int` `stoppage_time;`   `    ``// Constructor` `    ``Train(String train_num,` `        ``int` `arrival_time,` `        ``int` `stoppage_time)` `    ``{` `        ``this``.train_num = train_num;` `        ``this``.arrival_time = arrival_time;` `        ``this``.stoppage_time = stoppage_time;` `    ``}` `}`   `public` `class` `GFG {` `    ``// Function to find the platform` `    ``// on which train F arrives` `    ``static` `int` `findPlatformOf(` `        ``ArrayList trains, ``int` `n,` `        ``String F)` `    ``{` `        ``// Sort the array arr[] according` `        ``// to the arrival time` `        ``Collections.sort(` `            ``trains,` `            ``(a, b) -> a.arrival_time==b.arrival_time ? Integer.parseInt(a.train_num)-Integer.parseInt(b.train_num) : a.arrival_time - b.arrival_time);`   `        ``// Stores the platforms that` `        ``// is in currently in use` `        ``PriorityQueue<``int``[]> pq` `            ``= ``new` `PriorityQueue<>(` `                ``(a, b)` `                    ``-> a[``1``] == b[``1``] ? a[``0``] - b[``0``]` `                                    ``: a[``1``] - b[``1``]);`   `        ``// Insert the platform number 1` `        ``// with departure time as 0` `        ``pq.add(``new` `int``[] { ``1``, ``0` `});`   `        ``// Store the platform number` `        ``// on which train arrived` `        ``HashMap schedule` `            ``= ``new` `HashMap<>();`   `        ``// Traverse the given array` `        ``for` `(Train t : trains) {`   `            ``// Pop the top platform of` `            ``// the priority queue` `            ``int``[] free_platform = pq.poll();`   `            ``// If arrival time of the train` `            ``// >= freeing time of the platform` `            ``if` `(t.arrival_time >= free_platform[``1``]) {` `                ``// Update the train status` `                ``free_platform[``1``]` `                    ``= t.arrival_time + t.stoppage_time + ``1``;`   `                ``// Add the current platform` `                ``// to the pq` `                ``pq.add(free_platform);`   `                ``// Add the platform` `                ``// number to the HashMap` `                ``schedule.put(t.train_num,` `                            ``free_platform[``0``]);` `            ``}`   `            ``// Otherwise, add a new platform` `            ``// for the current train` `            ``else` `{`   `                ``// Update the priority queue` `                ``pq.add(free_platform);`   `                ``// Get the platform number` `                ``int` `platform_num = pq.size() + ``1``;`   `                ``// Add the platform to` `                ``// the priority queue` `                ``pq.add(``new` `int``[] {` `                    ``platform_num,` `                    ``t.arrival_time` `                        ``+ t.stoppage_time + ``1` `});`   `                ``// Add the platform` `                ``// number to the HashMap` `                ``schedule.put(t.train_num,` `                            ``platform_num);` `            ``}` `        ``}`   `        ``// Return the platform on` `        ``// which F train arrived` `        ``return` `schedule.get(F);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``ArrayList trains` `            ``= ``new` `ArrayList<>();`   `        ``trains.add(``new` `Train(`   `            ``"112567"``, ``2``, ``1``));` `        ``trains.add(``new` `Train(` `            ``"112569"``, ``5``, ``5``));` `        ``trains.add(``new` `Train(` `            ``"112563"``, ``5``, ``3``));` `        ``trains.add(``new` `Train(` `            ``"112560"``, ``3``, ``7``));` `        ``String F = ``"112563"``;`   `        ``System.out.println(` `            ``findPlatformOf(` `                ``trains, trains.size(), F));` `    ``}` `}`

## Python3

 `from` `queue ``import` `PriorityQueue`   `# Stores the information for each` `# train as Objects` `class` `Train:` `    ``def` `__init__(``self``, train_num, arrival_time, stoppage_time):` `        ``# Stores the train number` `        ``self``.train_num ``=` `train_num` `        ``# Stores the arrival time` `        ``self``.arrival_time ``=` `arrival_time` `        ``# Stores the stoppage time` `        ``self``.stoppage_time ``=` `stoppage_time`   `# custom search comparator` `def` `sortArrivalTime(train):` `    ``return` `(train.arrival_time, train.train_num)`   `# Function to find the platform` `# on which train F arrives` `def` `findPlatformOf(trains, n, F):` `    ``# Sort the array arr[] according` `    ``# to the arrival time` `    ``trains.sort(key``=``sortArrivalTime)`   `    ``# Stores the platforms that` `    ``# is in currently in use` `    ``pq ``=` `PriorityQueue()`   `    ``# Insert the platform number 1` `    ``# with departure time as 0` `    ``temp ``=` `[``1``, ``0``]` `    ``pq.put((``-``temp[``1``], temp))`   `    ``# Store the platform number` `    ``# on which train arrived` `    ``schedule ``=` `{}`   `    ``# Traverse the given array` `    ``for` `t ``in` `trains:` `        ``# Pop the top platform of` `        ``# the priority queue` `        ``free_platform ``=` `pq.get()[``1``]`   `        ``# If arrival time of the train` `        ``# >= freeing time of the platform` `        ``if` `t.arrival_time >``=` `free_platform[``1``]:` `            ``# Update the train status` `            ``free_platform[``1``] ``=` `t.arrival_time ``+` `t.stoppage_time ``+` `1` `            ``# Add the current platform` `            ``# to the pq` `            ``pq.put((``-``free_platform[``1``], free_platform))`   `            ``# Add the platform` `            ``# number to the dictionary` `            ``schedule[t.train_num] ``=` `free_platform[``0``]` `        ``# Otherwise, add a new platform` `        ``# for the current train` `        ``else``:` `            ``# Update the priority queue` `            ``pq.put((``-``free_platform[``1``], free_platform))`   `            ``# Get the platform number` `            ``platform_num ``=` `pq.qsize() ``+` `1`   `            ``# Add the platform to` `            ``# the priority queue` `            ``temp ``=` `[platform_num, t.arrival_time ``+` `t.stoppage_time ``+` `1``]` `            ``pq.put((``-``temp[``1``], temp))`   `            ``# Add the platform` `            ``# number to the dictionary` `            ``schedule[t.train_num] ``=` `platform_num`   `    ``# Return the platform on` `    ``# which F train arrived` `    ``return` `schedule[F]`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``trains ``=` `[]` `    ``trains.append(Train(``"112567"``, ``2``, ``1``))` `    ``trains.append(Train(``"112569"``, ``5``, ``5``))` `    ``trains.append(Train(``"112563"``, ``5``, ``3``))` `    ``trains.append(Train(``"112560"``, ``3``, ``7``))` `    ``F ``=` `"112563"`   `    ``print``(findPlatformOf(trains, ``len``(trains), F))`   `# This code is contriibuted by Aditya Sharma`

## C#

 `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `public` `class` `Train {` `    ``public` `string` `train_num;` `    ``public` `int` `arrival_time;` `    ``public` `int` `stoppage_time;`   `    ``public` `Train(``string` `train_num, ``int` `arrival_time, ``int` `stoppage_time) {` `        ``this``.train_num = train_num;` `        ``this``.arrival_time = arrival_time;` `        ``this``.stoppage_time = stoppage_time;` `    ``}` `}`   `public` `class` `PlatformComparator : IComparer<``int``[]> {` `    ``public` `int` `Compare(``int``[] platform1, ``int``[] platform2) {` `        ``if` `(platform1 == platform2) {` `            ``return` `platform1.CompareTo(platform2);` `        ``}` `        ``return` `platform1.CompareTo(platform2);` `    ``}` `}`   `public` `class` `Program {` `    ``public` `static` `int` `FindPlatformOf(List trains, ``int` `n, ``string` `F) {` `        ``trains.Sort((x, y) => x.arrival_time.CompareTo(y.arrival_time));`   `        ``var` `pq = ``new` `SortedSet<``int``[]>(``new` `PlatformComparator());`   `        ``var` `temp = ``new` `int``[] { 1, 0 };` `        ``pq.Add(temp);`   `        ``var` `schedule = ``new` `Dictionary<``string``, ``int``>();`   `        ``foreach` `(``var` `t ``in` `trains) {` `            ``var` `free_platform = pq.Min;` `            ``pq.Remove(free_platform);`   `            ``if` `(t.arrival_time >= free_platform) {` `                ``free_platform = t.arrival_time + t.stoppage_time + 1;` `                ``pq.Add(free_platform);`   `                ``schedule[t.train_num] = free_platform;` `            ``} ``else` `{` `                ``pq.Add(free_platform);`   `                ``int` `platform_num = pq.Count + 1;`   `                ``var` `new_platform = ``new` `int``[] { platform_num, t.arrival_time + t.stoppage_time + 1 };` `                ``pq.Add(new_platform);`   `                ``schedule[t.train_num] = platform_num;` `            ``}` `        ``}`   `        ``return` `schedule[F];` `    ``}`   `    ``public` `static` `void` `Main() {` `        ``var` `trains = ``new` `List() {` `            ``new` `Train(``"112567"``, 2, 1),` `            ``new` `Train(``"112569"``, 5, 5),` `            ``new` `Train(``"112563"``, 5, 3),` `            ``new` `Train(``"112560"``, 3, 7),` `        ``};`   `        ``string` `F = ``"112563"``;`   `        ``Console.WriteLine(FindPlatformOf(trains, trains.Count, F));` `    ``}` `}`

## Javascript

 `// JavaScript code for the approach`   `// Define Train class` `class Train {` `    ``// Constructor to initialize the train number, arrival` `    ``// time, and stoppage time` `    ``constructor(train_num, arrival_time, stoppage_time)` `    ``{` `        ``this``.train_num = train_num;` `        ``this``.arrival_time = arrival_time;` `        ``this``.stoppage_time = stoppage_time;` `    ``}` `}`   `// Define PlatformComparator class to compare platforms` `// based on their availability times` `class PlatformComparator {` `    ``// Compare function to compare two platforms` `    ``compare(platform1, platform2)` `    ``{` `        ``// If the availability times of both platforms are` `        ``// same, compare based on platform number` `        ``if` `(platform1 == platform2) {` `            ``return` `platform1 - platform2;` `        ``}` `        ``// Otherwise, compare based on availability time` `        ``return` `platform1 - platform2;` `    ``}` `}`   `// Function to find the platform of a given train based on` `// its arrival time and stoppage time` `function` `findPlatformOf(trains, n, F)` `{` `    ``// Sort the trains based on their arrival times` `    ``trains.sort((x, y) => x.arrival_time - y.arrival_time);`   `    ``// Create a set to keep track of available platforms,` `    ``// and add the first platform with number 1 and` `    ``// availability time 0` `    ``let pq = ``new` `Set();` `    ``let temp = [ 1, 0 ];` `    ``pq.add(temp);`   `    ``// Create a dictionary to store the platform number for` `    ``// each train` `    ``let schedule = {};`   `    ``// Iterate over all the trains` `    ``for` `(let t of trains) {` `        ``// Find the platform with the earliest availability` `        ``// time` `        ``let free_platform = [... pq];` `        ``pq.``delete``(free_platform);` `        ``// If the train can use the platform immediately,` `        ``// update the availability time of the platform and` `        ``// assign it to the train` `        ``if` `(t.arrival_time >= free_platform) {` `            ``free_platform` `                ``= t.arrival_time + t.stoppage_time + 1;` `            ``pq.add(free_platform);`   `            ``schedule[t.train_num] = free_platform;` `        ``}` `        ``else` `{` `            ``// If the train cannot use the platform` `            ``// immediately, add a new platform, update its` `            ``// availability time, and assign it to the train` `            ``pq.add(free_platform);`   `            ``let platform_num = pq.size + 1;`   `            ``let new_platform = [` `                ``platform_num,` `                ``t.arrival_time + t.stoppage_time + 1` `            ``];` `            ``pq.add(new_platform);`   `            ``schedule[t.train_num] = platform_num;` `        ``}` `    ``}`   `    ``// Return the platform number of the desired train` `    ``return` `schedule[F];` `}`   `// Create an array of Train objects` `let trains = [` `    ``new` `Train(``"112567"``, 2, 1),` `    ``new` `Train(``"112569"``, 5, 5),` `    ``new` `Train(``"112563"``, 5, 3),` `    ``new` `Train(``"112560"``, 3, 7),` `];`   `// Define the train number for which the platform needs to` `// be found` `let F = ``"112563"``;`   `// Call the findPlatformOf function with the given trains,` `// length of trains array, and desired train number` `console.log(findPlatformOf(trains, trains.length, F));`

Output:

`3`

Time Complexity: O(N * log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up