Skip to content
Related Articles

Related Articles

Schedule elevator to reduce the total time taken

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 01 Jun, 2022
View Discussion
Improve Article
Save Article

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 <bits/stdc++.h>
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[0]);
    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




<script>
 
// JavaScript implementation of the approach
 
// Function to return the minimum time taken
// by the elevator when operating optimally
function minTime(n , k , a)
{
    // Sort in descending order
    var temp;
    for(var i = 0; i < n; i++)
    {    
        for(var j = i + 1; j < n; j++)
        {
            if(a[i] < a[j])
            {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }   var minTime = 0;
 
    // Iterate through the groups
    for (var 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
var k = 2;
var arr = [ 2, 3, 4 ];
var n = arr.length;
document.write(minTime(n, k, arr));
 
// This code is contributed by Amit Katiyar
 
</script>

Output

12

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!