Algorithm 寻找一个最优的在线分配算法

我正在寻找一个任务分配问题的解决方案，其中任务需要按顺序分配，但您可以让任务最多等待K个周期

形式上，让任务有一个有序的序列aabbaba。。。和一个有序的资源序列abbaa…，并且系统可以使用一个侧堆栈。目的是将大多数a（resp b）任务与a（resp b）资源相匹配。 约束条件如下：程序的每个时段i获取资源i并将其分配给任务。资源要么被分配给堆栈中的任务，要么继续按顺序从任务序列中读取。读取的每个任务都可以立即分配给资源i，或者如果它在那里等待的时间少于K个周期，并且将分配给它的匹配项（a->a，b->b），则可以将其放在堆栈上

如果K=0，则必须将第i个任务分配给第i个资源，这非常糟糕。如果K>0，则使用贪婪算法可以做得更好。什么是最佳解决方案

澄清：

用排列m表示分配，其中m（i）=j表示资源j被分配给任务i。如果没有堆栈m（i）=i。当存在堆栈时，可以按顺序分配任务，但如果将比我晚的任务放入堆栈中，则必须为我分配以下K个资源之一。也就是说，如果对于所有任务i：

m（i）i}+K

---

我正在寻找一种算法，该算法将在满足约束的所有分配中找到未命中分配（aB或bA）最少的分配

您可以用以下方式来描述问题：

ressources=[a,b,b,a,b,a,a,...]
tasks=[a,a,b,b,a,b,a,...]

我们可以定义将任务j分配给资源i的成本函数：

C(i,j)= (ressources[i]==tasks[j])*1+(ressources[i]!=tasks[j])*1000

如果您无法满足要求，我将选择1000>>1

让我们编写约束条件：

• xi，如果将任务j分配给 ressource j，否则为0
此外，如果i j＞k 因为你一个接一个地跟踪资源 你可以等k周期max（i-jK
• xi，j>=0，否则

您可能需要更正一点约束…一旦更正，此解决方案应该是最优的，但我不确定贪婪算法是否已经是最优的

将此公式与两种以上的资源一起使用会变得更有趣

希望我能理解你的问题，这会有帮助

---

修改：

if xi,j =1 then Sum(j*xi,j on i) = j since only one xi,j = 1

我将转换此约束：

m（i）i}+K

注意：

if xi,j =1 then Sum(j*xi,j on i) = j since only one xi,j = 1

“翻译”：

if xi,j =1 then Sum(j*xi,j on i) = j since only one xi,j = 1

使用前面的符号：

_m(i) <= Min{ m(i') s.t.  i'> i } + K_ 

< = > j <= Min{j' s.t i'>i and xi',j' =1 } + K_  (OK ?)

\u m（i）i}+K\u
<=>j i和xi'，j'=1}+K_（好吗？）

新的线性约束：

if xi,j =1 then Sum(j*xi,j on i) = j since only one xi,j = 1

我们有：

xi,j=1  < = > Sum(j*xi,j on j) = j for i

and 

xi',j'=1  < = > Sum(j'*xi',j' on j') = j'  for all i'

xi，j=1<=>和（j*xi，j在j上）=i的j
及
xi'，j'=1<=>和（j'*xi'，j'on j'）=j'代表所有i'

因此：

j <= Min{j' s.t i'>i and xi',j' =1 } + K_ 

< = >

Sum(j*xi,j on j)  <= Min { Sum(j'*xi',j' on j') , i'>i} + K 

ji和xi'，j'=1}+K_
< = >
和（j*xi，j对j）i

您可以将这些约束添加到前面的约束中，得到一个线性规划。

---

你可以用单纯形算法来解决这个问题，如果你不能满足要求，该怎么办？等待是否会带来任何成本？如果你不能满足要求，你将被迫错过匹配任务并支付成本。任何可用的资源都必须与某个任务匹配，并保留任务堆栈成本较低（如果低于K个周期）。谢谢。这几乎是正确的公式，但约束条件有点不同。约束条件取决于任务在堆栈中等待的时间，因此它取决于任务进入任务的时间。请参阅重新编辑的问题。我用您的新约束条件更正了我的答案，希望它能起作用。谢谢。线性规划是我正在寻找的问题我希望有一个更具建设性的算法。上面的线性规划应该可以工作（如果m（I）I}+K是我必须添加的唯一约束）。因此，如果你正在寻找一个线性规划，这应该是正确的答案（即使它们几乎是n个平方方程）一个更具建设性的算法是贪婪算法，它有一个约束条件：使侧线中的元素数量尽可能少。