Algorithm 这种贪婪的调度算法在哪里变得次优？_Algorithm_Math_Greedy_Bin Packing

Algorithm 这种贪婪的调度算法在哪里变得次优？

algorithm math

Algorithm 这种贪婪的调度算法在哪里变得次优？,algorithm,math,greedy,bin-packing,Algorithm,Math,Greedy,Bin Packing,这个问题的灵感来自于对流程分配的研究。这是对这里讨论的问题的扭曲和强化我们有n个进程，需要将它们分配到尽可能少的处理器。每个流程都有一个计划的开始和完成时间，我们将以时间单位定义，从1开始索引；进程将运行一些连续的时间单位序列。然后可以安排处理器运行任意数量的非重叠进程显而易见的贪婪算法是：在每个步骤中，将剩余进程的最大非重叠集调度到下一个处理器上如何选择最大不重叠集？我们将把算法保留为非确定性，因为这样更容易分析并分成两个子问题从本质上讲，前面的问题与算法不吉利时的行为有关：该算法可

这个问题的灵感来自于对流程分配的研究。这是对这里讨论的问题的扭曲和强化

我们有n个进程，需要将它们分配到尽可能少的处理器。每个流程都有一个计划的开始和完成时间，我们将以时间单位定义，从1开始索引；进程将运行一些连续的时间单位序列。然后可以安排处理器运行任意数量的非重叠进程

显而易见的贪婪算法是：

在每个步骤中，将剩余进程的最大非重叠集调度到下一个处理器上

如何选择最大不重叠集？我们将把算法保留为非确定性，因为这样更容易分析并分成两个子问题

从本质上讲，前面的问题与算法不吉利时的行为有关：该算法可能产生次优分配的最小n是多少（即，需要比需要更多的处理器）？结果证明，答案是n=4。有些情况下，两个处理器就足够了，但贪婪算法可能需要三个处理器（不过如果幸运的话，它将分两步完成）

这个问题涉及到如果非决定论总是幸运的话会发生什么：

该算法保证次优的最小n是多少？也就是说，对于贪心算法必须使用比需要更多进程的一组进程，我们能找到的最小n是多少

由于堆栈溢出，我将在这里这样做，您可以告诉我我的部分答案是否可以改进

我认为答案是n=7。我将试着证明n=7会出问题；但这只给出了一个上限。n=6会出问题吗？我不这么认为，但我不确定

上限假设我们要安排以下流程：

```
[1]
```
（即流程在时间单位1内运行）
```
[2]
```
```
[4]
```
```
[5]
```
```
[1,2,3]
```
（即流程在时间单位1到3期间运行）
```
[2,3,4]
```
```
[3,4,5]
```

最佳分配似乎需要三个处理器：

[1]

，

[2,3,4]

[2]

，

[3,4,5]

[1,2,3]

，

[4]

，

[5]

但贪婪算法将产生以下结果：

[1]

，

[2]

，

[4]

，

[5]

[1,2,3]

[2,3,4]

[3,4,5]

这里的关键点是，它将在第一步安排四个（因为它是贪婪的），然后我们剩下三个成对重叠的过程

下限 n=6会出问题吗？我不这么认为，但我不确定。在我看来，最佳解决方案需要三个处理器，每个处理器运行两个进程。我们能否找到这样一种情况：贪婪算法在第一个处理器上调度三个进程，然后剩下三个重叠的进程，因此总共需要四个处理器

我们需要三对，以获得最优解；但是我们需要以这样一种方式构建这些过程，如果你在第一步安排其中三个，你就不能在两个步骤中完成。很明显，这三个过程不能包含一对，否则解决方案可以继续，就像它对这些对所做的那样，但将其中一个作为一个单体。所以它必须从每一对中取一个

如果一个进程可能需要非连续的时间块，我们可以这样做：

```
[1]
```
```
[2]
```
```
[3]
```
```
[1,2]
```
```
[2,3]
```
```
[1,3]
```
（这是不允许的，因为它会停止并再次启动！）

最优解是将每个单态与其补码配对；贪婪算法会在第一步将所有的单例放在一起，然后我们剩下的成对重叠进程将需要三个以上的处理器。但是我们作弊了，因为上面列出的最后一个进程没有在连续的时间段内运行

我们无法将最后一个更改为

[3,4]

，因为这样它就可以与

[1,2]

在同一个处理器上运行。事实上，我们不能有三个成对重叠的连续块，除非它们的交集是非空的。因此，我们最终会得到类似于

[1,2,3]

，

[2,3,4]

，

[3,4,5]

，就像我们在七个流程案例中所做的那样。问题在于，如果不考虑使用三元组中的一个来调度两个单元组，那么似乎不可能再添加三个可以一起调度的进程，并且仍然允许三个处理器的最优解决方案。如果我们尝试

```
[1]
```
```
[2]
```
```
[4]
```
```
[1,2,3]
```
```
[2,3,4]
```
```
[3,4,5]
```

然后贪婪算法可能会在第一步安排

[1]

，

[2]

，

[3,4,5]

，这将导致一个最优解决方案（我们正在寻找一种非确定性保证导致次优解决方案的情况）

如果我们尝试

```
[2]
```
```
[3]
```
```
[4]
```
```
[1,2,3]
```
```
[2,3,4]
```
```
[3,4,5]
```

然后，我们在三个处理器上没有最优解决方案，因为其中四个进程需要时间单位3

所有这些思考向我表明，贪婪算法在n=6的情况下是最优的，因此n=7的上界是严格的；但它落在老鼠身上