基于时间粒的间断配送调度问题

Question

我有以下时间安排优化问题：

有n个Rest时间要安排。一次Rest占用每个15分钟的k时间颗粒。我看到的总视界是m个时间颗粒。每次谷物都有一个需要优化的中断量。开始中断的范围是每个中断定义的，您不能自由选择范围。

break.scala：

case class Break(vehicleId: String, durationInGrains: Int)

Timegrain.scala：

@PlanningEntity
case class TimeGrain(desiredBreaks: Int,
                     instant: Instant,
                     @CustomShadowVariable(...), // Dummy annotation, I want to use the entity in constraint stream 
                     var breaks: Set[Break])

中断分配：

@PlanningEntity
case class BreakAssignment(
  break: Break,
  @PlanningVariable(valueRangeProviderRefs = Array("timeGrainRange"))
  var startingTimeGrain: TimeGrain,
  @ValueRangeProvider(id = "timeGrainRange")
  @ProblemFactCollectionProperty @field
  timeGrainRange: java.util.List[TimeGrain],
  @CustomShadowVariable(
    variableListenerClass = classOf[StartingTimeGrainVariableListener],
    sources = Array(new PlanningVariableReference(variableName = "startingTimeGrain"))
  )
  var timeGrains: util.Set[TimeGrain]
)

object BreakAssignment {
  class StartingTimeGrainVariableListener extends VariableListener[Solution, BreakAssignment] {
    override def afterVariableChanged(scoreDirector: ScoreDirector[Solution], entity: BreakAssignment): Unit = {
      val end = entity.startingTimeGrain.instant
        .plusSeconds((entity.break.durationInGrains * TimeGrain.grainLength).toSeconds)
      scoreDirector.getWorkingSolution.timeGrains.asScala
        .filter(
          timeGrain =>
            timeGrain.instant == entity.startingTimeGrain.instant ||
            entity.startingTimeGrain.instant.isBefore(timeGrain.instant) && end
              .isAfter(timeGrain.instant)
        )
        .foreach { timeGrain =>
          scoreDirector.beforeVariableChanged(timeGrain, "breaks")
          timeGrain.breaks = timeGrain.breaks + entity.break
          scoreDirector.afterVariableChanged(timeGrain, "breaks")
        }
    }
  }
}

private def constraint(constraintFactory: ConstraintFactory) =
  constraintFactory
    .from(classOf[TimeGrain])
    .filter(timeGrain => timeGrain.breaks.nonEmpty)
    .penalize(
      "Constraint",
      HardSoftScore.ONE_SOFT,
      (timeGrain: TimeGrain) => {
        math.abs(timeGrain.desiredBreaks - timeGrain.breaks.size)
      }
    )

我在想出正确的模型的时候，是不是走错了方向？

Answer 1

如果我正确理解您的意思，那么从概念上讲，在TimeGrain类中，我将保留一个（自定义）shadow变量（仅）保留与该TimeGrain（实例）重叠的Break实例的计数。为了简单起见，我叫它breakCount。让我称x为一个中断所跨越的时间颗粒数。

因此，当求解器将一个Break实例分配给一个TimeGrain实例时，我将增加该TimeGrain实例的Break Count。不仅要计算THát TimeGrain实例的breakCount，还要计算接下来几个(x-1)个TimeGrain实例的breakCount。请注意将这些增量中的每一个都包装在“ScoreDirector.BeforeVariableChanged（）”-“ScoreDirector.AfterVariableChanged（）”括号中。

剩下的就用分数计算了。但请注意，我自己还会将时间颗粒的理想中断计数和它的“真实”中断计数（即阴影变量）的差平方，就像OptaPlanner的文档中解释的那样，以加强更多的“公平性”。

编辑：当然，在从时间颗粒实例中删除中断实例时，也会减少时间颗粒的中断计数...