Algorithm 一类总损失最小的作业调度问题

假设我们有

n个

作业要调度，我们希望找到一个作业调度顺序，以实现最小的总损失。每个作业有三个属性：

（b，l，k）

其中

b

表示每个作业的未来时间，

l

表示运行所需的时间，

k

是系数。当一个作业被服务时，它不能被抢占，我们只有一台机器。作业的等待时间定义为服务时间–到达时间​. 我们将作业的损失定义为等待时间乘以k

例如，我们有三个作业：

（0,10,1）、（2,3,5）、（4,7,3）

。如果我们按照其初始顺序

1,2,3

，则每个作业的损失分别为

0，（10-2）×5=40，（13-4）×3=27

，总损失为67。然而，如果我们按照顺序

2,3,1

，我们可以得到更低的总损失

0+12+3=15

。这意味着，尽管第一个作业在时间0出现，但我们无法处理它。相反，在完成第三个作业之前，我们选择第一个作业进行调度。以下是顺序

2,3,1

我认为这个问题和操作系统中的SJF算法有点相似，但也有很大的不同

这是我思考的主要部分。基本上我想出了一个贪婪的算法。我维护一个

deque

，以保持以前发生但未及时处理的工作。当我们需要为工作安排一份工作时，我考虑德克的工作和当一份工作服务时的工作。我比较这些工作之间的损失，以找到一个工作，得到额外的损失。嗯……我的英语不好。如果有人想读更多，请转到我的

我想知道是否存在动态规划算法或其他启发式算法来获得更好的近似解？

下面是我用

C++

编写的代码的主要部分：

向量顺序；
德克q；
int curr_idx=0，curr_time=0；
长期总损耗=0；
while（curr_idxlast*（k_sum-it->k）；
如果（损失<最小损失）{
min_it=它；
最小损耗=损耗；
}
}
订单。推回（min_it->beg）；
总损耗+=最小损耗；
当前时间+=min\u it->last；
k_sum-=min_it->k；
q、 擦除（minu_it）；
}
打破
}
//系统初始情况或者期间没有任务及时到来
//推进当前时间，相当于指针在时间轴往前跑，直到找到一个新的任务
//当用来将同时刻的任务全部入队
if（q.empty（））{
int time=segs[curr_idx].beg；
while（curr_idxlast*（k_sum-it->k）//若选当前任务，当其执行完毕时的队列其他任务新增损失
int idx=当前idx；
//区间内到达任务由于目前在处理信息技术任务而造成的新增损失
while（idxlast-segs[idx].beg）*segs[idx].k；
idx++；
}
如果（损失<最小损失）{
最小损耗=损耗；
min_it=它；
in_queue=true；
}
//开始比较是否可以先执行在后续区间内的任务能带来更小的损失
for（int i=curr_idx；ibeg）；
q、 擦除（minu_it）；
while（curr_idx0，（10-2）×5=40，（13-4）×3=27那么，0、10和13是发球时间，而不是未来时间。因为我们选择
（0,10,1）
首先安排作业
(2,3,5)
必须等到第一个作业结束，时间是10。因此，第二个作业的等待时间是10-2=8，其损失是8*5=40，第三个作业也是一样。n可以有多大？时间可以有多大？对它没有特别的限制。但是你可以假设
n
在
100
以下，而
time
在下r
1000
。
n
我对我的节点进行的测试处于
10
下，因为我必须使用蛮力来检查其准确性：）是的，好的，仍然不清楚当顺序为2、3、1时，你的损失是12、0、7。你能编辑你的qu吗