给定两个数组box []和truck [] ，其中box [i]代表第i个箱子的重量，而truck [i]代表第i个卡车可以承受的最大负载。现在，每辆卡车要花一个小时将一个箱子从源头运到目的地，然后又要花一个小时才能回来。现在，假设所有箱子都存放在源头，那么任务是找到将所有箱子从源头运送到目的地所需的最短时间。请注意，总是有一段时间可以运输箱子，并且在任何时候都只能用卡车搬运一个箱子。
例子：
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 truck are back on the source location.
Now, truck[1] cannot carry anymore boxes as all the remaining boxes
have weights more than the capacity of truck[1].
So, truck[0] will carry box[1] and box[2]
in 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
方法：想法是使用二进制搜索并对两个数组进行排序，此处的下限为0 ，上限为2 * box []的大小，因为在最坏的情况下，运输所有盒子所需的时间将为2 *盒数组的大小，现在计算中间值，对于每个中间值，检查加载程序是否可以在时间=中间时间内运输所有盒子。如果是，则将上限更新为中– 1 ，如果否，则将下限更新为中+ 1 。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
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 RyugaC#
// 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
= $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
?>输出：
3