可以在没有蛮力的情况下找到安排任务的最短时间吗？

Question

如果我有一个整数列表，表示完成一项任务所需的时间，并且我有 x 个工作人员只能处理一项任务，直到完成所需的时间结束，我能找到它的最短时间吗可能会采取最好的情况吗？我不需要构成这个最短完成时间的确切排列，只需要时间。

例如，为了简单起见，如果我有一个列表 [2, 4, 6] 并且我有 2 个工作人员，那么如果我从 2 和 4 开始，那么当 2 完成时 6 将开始，这意味着需要 8 秒完成所有任务。但是，如果我从 6 和 2 开始，那么当 2 完成时，4 将与 6 同时开始和完成，因此如果按此顺序完成任务，则只需 6 秒。

有没有比n 知道只需要6 秒的方法！还是蛮力复杂性保证它是可能的最短时间？感谢您提前提供的任何帮助，如果我遗漏了任何细节或您感到困惑，请随时提出问题！

编辑：请帮助:(

编辑 2：有可能吗？有人知道吗？

Answer 1

在单个worker的情况下，实际所需的总时间与所有任务时间的总和相同。

jobs = [ 2, 4, 6, etc... ]
time_required = SUM( jobs )

如果有两个工人，那么给定特定的工作顺序，所需的总时间可以通过首先将每个任务的所需时间分配给具有当前最低总和的工人来确定，然后获得与每个工人相关的最高总和：

define type worker  = vector<time_t>
define type workers = min_priority_queue<worker> using worker.sum() # so the current worker.sum() (the sum of `time_t` values in `vector<time_t>`) is the priority-queue key.
define type task    = int

jobs = [ 2, 4, 6, etc... ]

# Use two workers:
workers.add( new worker )
workers.add( new worker )

# Iterate once through each job:
foreach( task t in jobs ) {

    minWorker = workers.getMinWorker() # priority queue "find-min" operation
    minWorker.add( t )
}

# Determine which worker will work the longest time:
time_required = workers.getMaxWorker().sum() # priority queue "find-max" operation

因为这是一个实际的解决方案，所以 time_required 是一个存在于上限和下限之间的点样本 - 这并不是您所追求的，而是因为它可以在 @987654325 中计算@time 这是一个很好的起点。

然后可以将上述算法推广到任意数量的工作人员，只需将它们添加到优先级队列 - 因为基于堆的优先级队列的 find-min 操作是 O(1) 我相信这个算法在 O(n) 时间运行n 是工作数量，与工人数量无关。 （我可能对精确的运行时复杂度有误）。

至于在少于O(n!) 时间的时间内计算边界...这很棘手（至少对我来说，因为我上次破解my copy of CLRS 已经有几年了）。

对于任何个作业顺序的xworkers 的最小下界就是作业集中的最大单个值。

xworkers 对于任何个工作顺序的最大上限可能是最大的工作100 * (1/x) % 的总和（所以给定 2 个工作人员最大的 50% 工作的总和，对于 3 个工人，它是最大的 33% 工作的总和，对于 4 个工人，它是 25%，等等）。这将要求您首先对集合进行排序（如果使用 Quicksort，则采用 O(n log n)）。

jobs = [ 2, 4, 6, etc... ]

worker_count = 2

jobs.sortDescending() # O(n log n)

# if there's 50 jobs and 2 workers, then take the first 25 jobs and sum them...
# ...that's an upper_bound for the time required to complete all tasks by 2 workers, as it assumes that 1 unlucky worker will get all of the longest tasks

upper_bound = jobs.take( jobs.count / worker_count ).sum()