# Schedule elevator to reduce the total time taken

• Difficulty Level : Easy
• Last Updated : 01 Jun, 2022

Given an integer k and an array arr[] representing the destination floors for N people waiting currently at the ground floor and k is the capacity of the elevator i.e. maximum number of people it can hold at the same time. It takes 1 unit time for the elevator to reach any consecutive floor from the current floor. The task is to schedule the elevator in a way to minimize the total time taken to get all the people to their destination floor and then return back to the ground floor.
Examples:

Input: arr[] = {2, 3, 4}, k = 2
Output: 12
Second and the third persons (destination floors 3 and 4) shall go in the first turn taking 8 (4 + 4) unit time. The only person left will take 2 unit time to get to the destination
And then the elevator will take another 2 unit time to get back to the ground floor.
Total time taken = 8 + 2 + 2 = 12
Input: arr[] = {5, 5, 4}, k = 3
Output: 10
Every person can get on the elevator at the same time
Time required will be 10 (5 + 5).

Approach: Sort the given array in decreasing order of destination. Create groups of K (starting from the highest floor), the cost for each group will be 2 * (max(Elements in current group)). The summation across all groups will be the answer.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the minimum time taken``// by the elevator when operating optimally``int` `minTime(``int` `n, ``int` `k, ``int` `a[])``{``    ``// Sort in descending order``    ``sort(a, a + n, greater<``int``>());``    ``int` `minTime = 0;` `    ``// Iterate through the groups``    ``for` `(``int` `i = 0; i < n; i += k)` `        ``// Update the time taken for each group``        ``minTime += (2 * a[i]);` `    ``// Return the total time taken``    ``return` `minTime;``}` `// Driver code``int` `main()``{``    ``int` `k = 2;``    ``int` `arr[] = { 2, 3, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << minTime(n, k, arr);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{``// Function to return the minimum time taken``// by the elevator when operating optimally``public` `static` `int` `minTime(``int` `n, ``int` `k, Integer a[])``{``    ``// Sort in descending order``    ``Arrays.sort(a , Collections.reverseOrder());` `    ``int` `minTime = ``0``;` `    ``// Iterate through the groups``    ``for` `(``int` `i = ``0``; i < n; i += k)` `        ``// Update the time taken for each group``        ``minTime += (``2` `* a[i]);` `    ``// Return the total time taken``    ``return` `minTime;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``int` `k = ``2``;``    ``Integer arr[] = { ``2``, ``3``, ``4` `};``    ``int` `n = arr.length;``    ``System.out.println(minTime(n, k, arr));``}``}` `// This code is contributed by Pushpesh Raj.`

## Python3

 `# Python3 implementation of the approach` `# Function to return the minimum time taken``# by the elevator when operating optimally``def` `minTime(n, k, a) :``    ` `    ``# Sort in descending order``    ``a.sort(reverse ``=` `True``);``    ` `    ``minTime ``=` `0``;` `    ``# Iterate through the groups``    ``for` `i ``in` `range``(``0``, n, k) :` `        ``# Update the time taken for``        ``# each group``        ``minTime ``+``=` `(``2` `*` `a[i]);` `    ``# Return the total time taken``    ``return` `minTime;` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:``    ` `    ``k ``=` `2``;``    ``arr ``=` `[ ``2``, ``3``, ``4` `];``    ``n ``=` `len``(arr) ;``    ``print``(minTime(n, k, arr));``    ` `# This code is contributed by Ryuga`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `// Function to return the minimum time taken``// by the elevator when operating optimally``static` `int` `minTime(``int` `n, ``int` `k, ``int` `[]a)``{``    ``// Sort in descending order``    ``int` `temp;``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = i + 1; j < n; j++)``        ``{``            ``if``(a[i] < a[j])``            ``{``                ``temp = a[i];``                ``a[i] = a[j];``                ``a[j] = temp;``            ``}``        ``}``    ``}`  `    ``int` `minTime = 0;` `    ``// Iterate through the groups``    ``for` `(``int` `i = 0; i < n; i += k)` `        ``// Update the time taken for each group``        ``minTime += (2 * a[i]);` `    ``// Return the total time taken``    ``return` `minTime;``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `k = 2;``    ``int` `[]arr = { 2, 3, 4 };``    ``int` `n = arr.Length;``    ``Console.Write(minTime(n, k, arr));``}``}` `// This code is contributed by Arnab Kundu`

## Javascript

 ``

Output

`12`

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

My Personal Notes arrow_drop_up