Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum time required to transport all the boxes from source to the destination under the given constraints

  • Difficulty Level : Hard
  • Last Updated : 05 Aug, 2021

Given two arrays, box[] and truck[], where box[i] represents the weight of the ith box and truck[i] represents the maximum load that the ith truck can carry. Now each truck takes 1 hour to transport a box from source to destination and another one hour to come back. Now, given that all the boxes are kept at the source, the task is to find the minimum time required to transport all the boxes from the source to the destination. 

Note that there will always be some time in which the boxes can be transported and only a single box can be carried by truck at any instance of time.

Examples:  

Input: box[] = {7, 6, 5, 4, 3}, truck[] = {10, 3} 
Output: 7 
1st hour: truck[0] carries box[0] and truck[1] carries box[4] 
2nd hour: Both trucks are back at the source location. 
Now, truck[1] cannot carry anymore boxes as all the remaining boxes 
have weights more than the capacity of a truck[1]. 
So, truck[0] will carry box[1] and box[2] 
in a total of four hours. (source-destination and then destination-source) 
And finally, box[3] will take another hour to reach the destination. 
So, total time taken = 2 + 4 + 1 = 7

Input: box[] = {10, 2, 16, 19}, truck[] = {29, 25} 
Output: 3  

Approach: The idea is to use binary search and sort the two arrays. Here the lower bound will be 0 and the upper bound will be 2 * size of box[] because in the worst case, the amount of time required to transport all the boxes will be 2 * size of box array. Now compute the mid-value, and for each mid-value check if all the boxes can be transported by the loaders in time = mid. If yes, then update the upper bound as mid – 1 and if not, then update the lower bound as mid + 1.

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true if it is
// possible to transport all the boxes
// in the given amount of time
bool isPossible(int box[], int truck[],
                int n, int m, int min_time)
{
    int temp = 0;
    int count = 0;
 
    while (count < m) {
        for (int j = 0; j < min_time
                        && temp < n
                        && truck[count] >= box[temp];
             j += 2)
            temp++;
 
        count++;
    }
 
    // If all the boxes can be
    // transported in the given time
    if (temp == n)
        return true;
 
    // If all the boxes can't be
    // transported in the given time
    return false;
}
 
// Function to return the minimum time required
int minTime(int box[], int truck[], int n, int m)
{
 
    // Sort the two arrays
    sort(box, box + n);
    sort(truck, truck + m);
 
    int l = 0;
    int h = 2 * n;
 
    // Stores minimum time in which
    // all the boxes can be transported
    int min_time = 0;
 
    // Check for the minimum time in which
    // all the boxes can be transported
    while (l <= h) {
        int mid = (l + h) / 2;
 
        // If it is possible to transport all
        // the boxes in mid amount of time
        if (isPossible(box, truck, n, m, mid)) {
            min_time = mid;
            h = mid - 1;
        }
        else
            l = mid + 1;
    }
 
    return min_time;
}
 
// Driver code
int main()
{
    int box[] = { 10, 2, 16, 19 };
    int truck[] = { 29, 25 };
 
    int n = sizeof(box) / sizeof(int);
    int m = sizeof(truck) / sizeof(int);
 
    printf("%d", minTime(box, truck, n, m));
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.Arrays;
 
class GFG
{
 
// Function that returns true if it is
// possible to transport all the boxes
// in the given amount of time
static boolean isPossible(int box[], int truck[],
                int n, int m, int min_time)
{
    int temp = 0;
    int count = 0;
 
    while (count < m)
    {
        for (int j = 0; j < min_time
                        && temp < n
                        && truck[count] >= box[temp];
            j += 2)
            temp++;
 
        count++;
    }
 
    // If all the boxes can be
    // transported in the given time
    if (temp == n)
        return true;
 
    // If all the boxes can't be
    // transported in the given time
    return false;
}
 
// Function to return the minimum time required
static int minTime(int box[], int truck[], int n, int m)
{
 
    // Sort the two arrays
    Arrays.sort(box);
    Arrays.sort(truck);
 
    int l = 0;
    int h = 2 * n;
 
    // Stores minimum time in which
    // all the boxes can be transported
    int min_time = 0;
 
    // Check for the minimum time in which
    // all the boxes can be transported
    while (l <= h) {
        int mid = (l + h) / 2;
 
        // If it is possible to transport all
        // the boxes in mid amount of time
        if (isPossible(box, truck, n, m, mid))
        {
            min_time = mid;
            h = mid - 1;
        }
        else
            l = mid + 1;
    }
 
    return min_time;
}
 
// Driver code
public static void main(String[] args)
{
    int box[] = { 10, 2, 16, 19 };
    int truck[] = { 29, 25 };
 
    int n = box.length;
    int m = truck.length;
 
    System.out.printf("%d", minTime(box, truck, n, m));
}
}
 
/* This code contributed by PrinciRaj1992 */
Python3



# Python3 implementation of the approach
 
# Function that returns true if it is
# possible to transport all the boxes
# in the given amount of time
def isPossible(box, truck, n, m, min_time) :
     
    temp = 0
    count = 0
 
    while (count < m) :
        j = 0
        while (j < min_time and temp < n and
                    truck[count] >= box[temp] ):
            temp +=1
            j += 2
 
        count += 1
 
    # If all the boxes can be
    # transported in the given time
    if (temp == n) :
        return True
 
    # If all the boxes can't be
    # transported in the given time
    return False
 
# Function to return the minimum time required
def minTime(box, truck, n, m) :
 
    # Sort the two arrays
    box.sort();
    truck.sort();
 
    l = 0
    h = 2 * n
 
    # Stores minimum time in which
    # all the boxes can be transported
    min_time = 0
 
    # Check for the minimum time in which
    # all the boxes can be transported
    while (l <= h) :
        mid = (l + h) // 2
 
        # If it is possible to transport all
        # the boxes in mid amount of time
        if (isPossible(box, truck, n, m, mid)) :
            min_time = mid
            h = mid - 1
     
        else :
             
            l = mid + 1
 
    return min_time
 
# Driver code
if __name__ == "__main__" :
 
    box = [ 10, 2, 16, 19 ]
    truck = [ 29, 25 ]
 
    n = len(box)
    m = len(truck)
 
    print(minTime(box, truck, n, m))
     
# This code is contributed by Ryuga
C#



// C# implementation of the approach
using System;
     
class GFG
{
 
// Function that returns true if it is
// possible to transport all the boxes
// in the given amount of time
static bool isPossible(int []box, int []truck,
                int n, int m, int min_time)
{
    int temp = 0;
    int count = 0;
 
    while (count < m)
    {
        for (int j = 0; j < min_time
                        && temp < n
                        && truck[count] >= box[temp];
            j += 2)
            temp++;
 
        count++;
    }
 
    // If all the boxes can be
    // transported in the given time
    if (temp == n)
        return true;
 
    // If all the boxes can't be
    // transported in the given time
    return false;
}
 
// Function to return the minimum time required
static int minTime(int []box, int []truck, int n, int m)
{
 
    // Sort the two arrays
    Array.Sort(box);
    Array.Sort(truck);
 
    int l = 0;
    int h = 2 * n;
 
    // Stores minimum time in which
    // all the boxes can be transported
    int min_time = 0;
 
    // Check for the minimum time in which
    // all the boxes can be transported
    while (l <= h)
    {
        int mid = (l + h) / 2;
 
        // If it is possible to transport all
        // the boxes in mid amount of time
        if (isPossible(box, truck, n, m, mid))
        {
            min_time = mid;
            h = mid - 1;
        }
        else
            l = mid + 1;
    }
 
    return min_time;
}
 
// Driver code
public static void Main(String[] args)
{
    int[] box = { 10, 2, 16, 19 };
    int []truck = { 29, 25 };
 
    int n = box.Length;
    int m = truck.Length;
 
    Console.WriteLine("{0}", minTime(box, truck, n, m));
}
}
 
/* This code contributed by PrinciRaj1992 */
PHP



<?php
 
// PHP implementation of the approach
 
// Function that returns true if it is
// possible to transport all the boxes
// in the given amount of time
function isPossible($box, $truck,
                $n, $m, $min_time)
{
    $temp = 0;
    $count = 0;
 
    while ($count < $m)
    {
        for ( $j = 0; $j < $min_time
                        && $temp < $n
                        && $truck[$count] >= $box[$temp];
            $j += 2)
            $temp++;
 
        $count++;
    }
 
    // If all the boxes can be
    // transported in the given time
    if ($temp == $n)
        return true;
 
    // If all the boxes can't be
    // transported in the given time
    return false;
}
 
// Function to return the minimum time required
function minTime( $box, $truck, $n, $m)
{
 
    // Sort the two arrays
    sort($box);
    sort($truck);
 
    $l = 0;
    $h = 2 * $n;
 
    // Stores minimum time in which
    // all the boxes can be transported
    $min_time = 0;
 
    // Check for the minimum time in which
    // all the boxes can be transported
    while ($l <= $h) {
        $mid = intdiv(($l + $h) , 2);
 
        // If it is possible to transport all
        // the boxes in mid amount of time
        if (isPossible($box, $truck, $n, $m, $mid))
        {
            $min_time = $mid;
            $h = $mid - 1;
        }
        else
            $l = $mid + 1;
    }
 
    return $min_time;
}
 
// Driver code
$box = array( 10, 2, 16, 19 );
$truck = array( 29, 25 );
 
$n = sizeof($box);
$m = sizeof($truck);
 
echo minTime($box, $truck, $n, $m);
 
 
// This code is contributed by ihritik
 
?>
Javascript



<script>
 
// Js implementation of the approach
 
// Function that returns true if it is
// possible to transport all the boxes
// in the given amount of time
function isPossible( box, truck,
                 n, m, min_time)
{
    let temp = 0;
    let count = 0;
 
    while (count < m) {
        for (let j = 0; j < min_time
                        && temp < n
                        && truck[count] >= box[temp];
             j += 2)
            temp++;
 
        count++;
    }
 
    // If all the boxes can be
    // transported in the given time
    if (temp == n)
        return true;
 
    // If all the boxes can't be
    // transported in the given time
    return false;
}
 
// Function to return the minimum time required
function minTime(box, truck, n, m)
{
 
    // Sort the two arrays
    box.sort(function(a,b){return a-b });
    truck.sort(function(a,b){return a-b });
 
    let l = 0;
    let h = 2 * n;
 
    // Stores minimum time in which
    // all the boxes can be transported
    let min_time = 0;
 
    // Check for the minimum time in which
    // all the boxes can be transported
    while (l <= h) {
        let mid = Math.floor((l + h) / 2);
 
        // If it is possible to transport all
        // the boxes in mid amount of time
        if (isPossible(box, truck, n, m, mid)) {
            min_time = mid;
            h = mid - 1;
        }
        else
            l = mid + 1;
    }
 
    return min_time;
}
 
// Driver code
let box = [ 10, 2, 16, 19 ];
let truck = [ 29, 25 ];
let n = box.length;
let m = truck.length;
document.write(minTime(box, truck, n, m));
 
 
</script>
Output: 
3
 
Time Complexity: O(N * log(N))
Auxiliary Space: O(1) 

My Personal Notes
arrow_drop_up
Next

Number of visible boxes after putting one inside another
Recommended Articles
Page :
Color all boxes in line such that every M consecutive boxes are unique
01, Oct 19
Remove minimum characters from string to split it into three substrings under given constraints
26, Jun 20
Minimum steps to reach end of array under constraints
06, Nov 16
Count all possible paths from source to destination in given 3D array
17, Jan 22
Find duplicates under given constraints
01, Mar 17
Check if it is possible to form string B from A under the given constraints
02, May 19
Minimum cost path from source node to destination node via K intermediate nodes
15, Mar 21
Minimum boxes required to carry all gifts
09, Nov 18
Find minimum time to finish all jobs with given constraints
04, Oct 15
Number of paths from source to destination in a directed acyclic graph
28, Aug 18
Queries to check if a path made up of even numbers from source to destination exists in a Matrix
28, Sep 20
Shortest path from a source cell to a destination cell of a Binary Matrix through cells consisting only of 1s
17, Mar 21
Maximize boxes required to keep at least one black and one white shirt
02, Jul 21
Minimum number of stacks possible using boxes of given capacities
14, Feb 19
Add elements of given arrays with given constraints
29, Jul 16
Minimum time required to color all edges of a Tree
17, Jun 21
Minimum time required to fill given N slots
20, Jan 21
Minimum time required to reach a given score
04, Dec 20
Number of visible boxes after putting one inside another
16, Nov 17
Count the number of ways to fill K boxes with N distinct items
29, Apr 20
Find the number of boxes to be removed
24, Oct 18
Minimize number of boxes by putting small box inside bigger one
02, Jul 20
Check loop in array according to given constraints
06, Jan 17
Forming smallest array with given constraints
25, May 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sakshi_Srivastava
@Sakshi_Srivastava
Vote for difficulty
Current difficulty :
Hard





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!