完成所有订单的最短时间

吉克在 他家组织了一个聚会。他需要 为客人准备 N个（N≤103） 甜甜圈。 吉克 决定从附近的一家餐馆订购甜甜圈，这家餐馆有 L个 厨师，每个厨师的等级是 R。一个等级为 R 的厨师 可以在前 R 分钟 做一个甜甜圈 ，在接下来的 2R 分钟再做一个，在 3R 分钟 再做一个 ，以此类推。任务是找到所有订单都能完成的最短时间。

例子

输入。 N = 10, L = 4, rank[] = {1, 2, 3, 4}
输出。 12
解释。 等级为1的厨师，可以在1+2+3+4=10分钟内做出4个甜甜圈
等级为2的厨师，可以在2+4+6=12分钟内做出3个甜甜圈
等级为3的厨师，可以在3+6=9分钟内做出2个甜甜圈
等级为4的厨师，可以在4分钟内做出1个甜甜圈
甜甜圈总数=4+3+2+1=10和
所有人花费的最大时间=12分钟。

输入。 N = 8, L = 8, rank[] = {1, 1, 1, 1, 1, 1}
输出。 1
解释。 由于所有厨师的等级都是1，所以每个厨师1分钟可以做1个甜甜圈。
甜甜圈总数=1+1+1+1+1+1+1=8，最小时间=1分钟

天真的方法。 要解决这个问题，请遵循以下思路。

这个想法是在时间线上进行线性搜索，答案将是厨师可以制作N个甜甜圈的最短时间。

按照以下步骤来解决问题。

• 我们将从1到10000000进行迭代，然后每隔1分钟检查厨师是否能做出所有的N个甜甜圈
• 每隔第i分钟，计算每个厨师能做多少个甜甜圈。
  • 将所有厨师制作的甜甜圈加起来，检查是否大于或等于N。
• 我们可以很容易地计算出，在给定的约束条件下，答案将位于10000000之间。

**时间复杂度。**O(N * T)，其中T是时间范围的值。
**辅助空间。**O(1)

使用最短的时间来完成订单 二进制搜索:

为了解决这个问题，请遵循以下思路。

我们可以在时间线上进行二进制搜索，找出制作所有甜甜圈所需的最小时间。

按照步骤来解决这个问题。

• 由于答案在1和10000000之间，所以我们将采取2个边界，左边边界是1，右边边界是10000000。
  • 现在，我们将检查当前搜索空间的中点。中点=（左+右）/2。
  • 现在我们说X是所有厨师在中点时能做出的甜甜圈的数量。
  • 如果X≥N，那么，mid可能是答案，我们将通过把右边的边界分配给mid-1来减少搜索空间。
  • 当X<N时，答案将大于mid，所以我们可以通过把左边的边界分配给mid+1来减少搜索空间。
• 在遍历结束时可以得到最小的时间。

下面是上述方法的实现。

JAVA

// Java code to implement the approach
import java.io.*;
import java.util.Scanner;
class GFG {
public static boolean isPossible(int p, int[] cook, int n, int mid)
{
	int cnt = 0;
	for (int i = 0; i < n; i++) {

	// For each cook count the pratas
	int c = 0;
	int time = mid;

	// Time taken to cook each
	// pratas by ith cook
	int perpratas = cook[i];
	while (time > 0) {
		time = time - perpratas;
		if (time >= 0) {
		c += 1;
		perpratas += cook[i];
		}
	}
	cnt += c;
	if (cnt >= p)
		return true;
	}
	return false;
}
// Function to find the minimum time required
// to fulfill the orders
static int findMinTime(int n, int[] arr, int l)
{
	// write your code here
	int s = 0, e = 10000007;
	int mid, ans = -1;

	// Loop to implement binary search
	while (s <= e) {
	mid = (s + e) / 2;
	if (isPossible(n, arr, l, mid)) {
		ans = mid;
		e = mid - 1;
	}
	else {
		s = mid + 1;
	}
	}
	return ans;
}
public static void main(String[] args) {
	int N = 10, L = 4;
	int[] rank = new int[]{ 1, 2, 3, 4 };

	// Function call
	System.out.println(findMinTime(N, rank, L));
}
}

// This code is contributed by ksam24000

输出

12

时间复杂度**。**O(N*logN)。
辅助空间。O(1).