Question

我正在编写过程管理问题。假设有一系列工作需要一个接一个地完成，您必须在每个项目的work2之前完成work1。使用以下示例：

work1   8   6   2   4
work2   3   1   3   12

我们需要花费8个小时来完成第一列的工作1和另外3个小时，但是如果我们首先完成第4列的工作，那么接下来的12个小时，我们将有一些时间来完成第3列和第2列。最好将此列放在第一步。

我的直觉想法是work2是瓶颈，这意味着我们至少需要使用3 + 1 + 3 + 12 = 20来完成这笔交易。也就是说，尽可能多地使work2流程正常运行。我的算法是：对work2进行反向排序，然后对work1进行排序，因为我们希望保持work2进程尽可能的忙。

这是我的算法，看起来很有效：

class Solution(object):
    def least_time(self, intervals):
        intervals.sort(key = lambda x: (-x[1], x[0]))
        time1 = time2 = 0 
        print intervals
        for inv in intervals:
            item1, item2 = inv
            if time1 + item1 <= time2 + item2:
                time1 += item1 
                time2 += item2
            else:
                time1 += item1
                time2 = time1 + item2

        return time2


if __name__ == "__main__":
    s = Solution()
    invs = [(8,3), (6,1), (2,3), (4,12)]
    print(s.least_time(invs))




>>>[(4, 12), (2, 3), (8, 3), (6, 1)]
>>>21

可以在21小时内按上述顺序完成操作。

我的问题是： 1.我的算法正确吗？ 2.如何将这个问题扩展到n个作品？（工作1->工作2->工作3-> ...->工作）

Answer 1

我在下面举了一个例子，但是我认为网络搜索可以找到您真正想要的答案。

对于两台机器，可以使用约翰逊规则（https://en.wikipedia.org/wiki/Job_shop_scheduling#Jobs_consisting_of_multiple_operations）解决问题（https://en.wikipedia.org/wiki/Johnson%27s_rule）。

由于第一个参考文献讨论了合并约翰逊规则以处理多于两台机器的情况，所以我认为对于这种情况，没有其他更令人满意的解决方案。

假设您混合了两种作业。一个人走A两步，然后走B三步。另一个需要A进行三个步骤，然后B进行两个步骤。似乎可行的一种模式是将两个作业交替进行。 A忙于两步而B空闲。然后，B对该工作进行三个步骤，而A承担另一种工作。在那段时间的最后，A交给B一项工作，该工作花了三步使B分两次完成，而A承担了第一项工作。

因此，每个人都忙于在每个工作中执行两个到三个步骤。

我认为这不会来自您的预排序算法。

一种通用（但在计算上非常昂贵）的算法将是使用启发式的A *搜索，该算法表示从特定状态完成的时间是最大的（如果A持续保持忙碌，则耗费时间；如果保持连续繁忙）。不幸的是，有很多关于调度问题的文献，我不知道-我只知道它存在，而且大多数非平凡的问题都证明是NP完全的。

如何获得一系列作品中最短的时间？

1 个答案: