使用红帽流程自动化管理器中的 OptaPlanner 构建解决者

根据有限的资源及特定限制，计划问题 是一种最佳目标。最佳目标可以是任何数量，例如：

实现这些目标的能力取决于可用的资源数量。例如，以下资源可能会受限制：

您还必须考虑与这些资源相关的特定限制，如个人工作小时数、使用某些机器或其它设备间的兼容性。

红帽构建的 OptaPlanner 帮助 Java 编程人员有效地解决约束满意度问题。它将优化 heuristics 和 metaheuristics 合并起来，且有有效的分数计算。

提供的用例 可能是 NP-complete 或 NP-hard，这意味着应用以下语句：

含义在于解决您的问题可能比您预期的问题更难，因为两个常见的技术并不知道：

通过使用高级优化算法，OptaPlanner 在解决此类计划问题的适当解决方案。

计划问题有很多解决方案。

多种解决方案类别如下：

Counterintuively，可能的解决方案数量非常大（如果被正确计算），即使是很小的数据集。

在 planner-engine 分发文件夹中提供的示例中，大多数实例都有大量可能的解决方案。由于无法获得最佳解决方案，因此任何实施都强制评估所有可能的解决方案的子集。

OptaPlanner 支持一些优化算法，以便高效地通过这些算法来有效地处理大量可能的解决方案。

根据用例，某些优化算法会比其他性能更好，但无法预先了解。使用 OptaPlanner，您可以在 XML 或代码的几行中更改解决器配置来切换优化算法。

通常，计划问题至少有两个级别限制：

有些问题也有正的约束：

一些基本问题只具有硬限制。有些问题有三个或更多限制级别，如 hard、medium 和 soft 约束。

这些限制定义了计划问题 的分数计算 （也称为适合性 功能）。规划问题的每个解决方案都会以分数为准。使用 OptaPlanner 时，分数限制以面向对象的语言编写，如 Java，或者在 Drools 规则中使用。

这种类型的代码非常灵活，可扩展。

Red Hat Process Automation Manager 提供了几个 OptaPlanner 示例。您可以检查示例代码，并根据需要对其进行修改，以满足您的需要。

某些 OptaPlanner 示例可以解决问题，这些问题在学术 contests中呈现。下表中的 Contest 列列出了 contests。它还标识了示例，作为 一项测试的目的或不切实际的。真实的竞争 测试是满足以下标准的官方独立测试：

真实的 Contests 提供了 OptaPlanner 与竞争软件和学术研究的目标比较。

在 n 个大小小板上放置 n queens，以便无法互相攻击。最常见的 n queens puzzle 是 8 个queuzzle，有 n = 8 ：

约束：

本文档主要使用四个不同点。

建议的解决方案可能是：

图 3.1. 四点欺诈解决方案

以上解决方案是错误的，因为 queens A1 和 B0 可以相互攻击（因此可以说 B0 和 D0）。删除 queen B0 会尊重"不两种 queens"约束，但会破坏 "place n queens" 约束。

以下是一个正确的解决方案：

图 3.2. Four quele queuzzle 的正确解决方案

所有约束都已满足，因此解决方案正确。

请注意，大多数 n 个词汇都有多个正确的解决方案。我们将重点介绍查找特定 n 的单一正确的解决方案，而不是为特定 n 查找可能的正确解决方案。

4queens   has   4 queens with a search space of    256.
8queens   has   8 queens with a search space of   10^7.
16queens  has  16 queens with a search space of  10^19.
32queens  has  32 queens with a search space of  10^48.
64queens  has  64 queens with a search space of 10^115.
256queens has 256 queens with a search space of 10^616.

N queens 示例的实现还没有优化，因为它作为新手示例的功能。然而，它可以轻松地处理 64 queens。出现了一些变化，它已被显示，可轻松处理 5000 queens 等等。

3.6.1. N queens 的域模型

这个示例使用域模型解决四条问题。

• 创建域模型

  好的域模型可以方便理解和解决您的规划问题。

  这是 n queens 示例的域模型：

  public class Column {
  
      private int index;
  
      // ... getters and setters
  }

  public class Row {
  
      private int index;
  
      // ... getters and setters
  }

  public class Queen {
  
      private Column column;
      private Row row;
  
      public int getAscendingDiagonalIndex() {...}
      public int getDescendingDiagonalIndex() {...}
  
      // ... getters and setters
  }

• 计算搜索空间.

  Queen 实例有一个 Column （例如：0 为列 A，1 为列 B, …​）和一个 Row （its 行，例如 0 代表行 0，1 是行 1, …​）。

  可以根据列和行计算升序行和降序行。

  列和行索引从主板的左上角开始。

  public class NQueens {
  
      private int n;
      private List<Column> columnList;
      private List<Row> rowList;
  
      private List<Queen> queenList;
  
      private SimpleScore score;
  
      // ... getters and setters
  }

• 查找解决方案

  单个 NQueens 实例包含所有 Queen 实例的列表。它是 Solution 实施，它将提供给、被解决并从 Solver 中检索。

请注意，在四个 queens 示例中，NQueens getN（） 方法总是返回 4。

图 3.3. Four Queens 的解决方案

表 3.2. 域模型中的解决方案详情

	columnIndex	rowIndex	ascendingDiagonalIndex (columnIndex + rowIndex)	descendingDiagonalIndex (columnIndex - rowIndex)
A1	0	1	1 (**)	-1
B0	1	0 (*)	1 (**)	1
C2	2	2	4	0
D0	3	0 (*)	3	3

当两个 queens 共享同一列时，行或横线，如(*)和(**)，它们可以相互攻击。

有关本示例的详情，请参阅 Red Hat build of OptaPlanner quick start Guide。

给定城市列表，找到一个只访问每个城市的 salesman 最短导览。

该问题由 Wikipedia 定义。它是计算 计算中最广泛调查的问题之一。然而，在现实世界中，这通常只是规划问题的一部分，以及其他约束，如员工切换限制。

dj38     has  38 cities with a search space of   10^43.
europe40 has  40 cities with a search space of   10^46.
st70     has  70 cities with a search space of   10^98.
pcb442   has 442 cities with a search space of  10^976.
lu980    has 980 cities with a search space of 10^2504.

每周 10nis club 都有四个团队相互推断。将这四个点分配给团队。

硬约束：

Medium 约束：

软限制：

munich-7teams has 7 teams, 18 days, 12 unavailabilityPenalties and 72 teamAssignments with a search space of 10^60.

图 3.4. 域模型

为启动时间和房间分配每个会议。会议有不同的持续时间。

硬约束：

Medium 约束：

软限制：

50meetings-160timegrains-5rooms  has  50 meetings, 160 timeGrains and 5 rooms with a search space of 10^145.
100meetings-320timegrains-5rooms has 100 meetings, 320 timeGrains and 5 rooms with a search space of 10^320.
200meetings-640timegrains-5rooms has 200 meetings, 640 timeGrains and 5 rooms with a search space of 10^701.
400meetings-1280timegrains-5rooms has 400 meetings, 1280 timeGrains and 5 rooms with a search space of 10^1522.
800meetings-2560timegrains-5rooms has 800 meetings, 2560 timeGrains and 5 rooms with a search space of 10^3285.

安排每个授课内容进入一个时间，并入一个房间。

硬约束：

软限制：

这个问题由 国际时间选项卡 2007 年跟踪 3 定义。

comp01 has 24 teachers,  14 curricula,  30 courses, 160 lectures, 30 periods,  6 rooms and   53 unavailable period constraints with a search space of  10^360.
comp02 has 71 teachers,  70 curricula,  82 courses, 283 lectures, 25 periods, 16 rooms and  513 unavailable period constraints with a search space of  10^736.
comp03 has 61 teachers,  68 curricula,  72 courses, 251 lectures, 25 periods, 16 rooms and  382 unavailable period constraints with a search space of  10^653.
comp04 has 70 teachers,  57 curricula,  79 courses, 286 lectures, 25 periods, 18 rooms and  396 unavailable period constraints with a search space of  10^758.
comp05 has 47 teachers, 139 curricula,  54 courses, 152 lectures, 36 periods,  9 rooms and  771 unavailable period constraints with a search space of  10^381.
comp06 has 87 teachers,  70 curricula, 108 courses, 361 lectures, 25 periods, 18 rooms and  632 unavailable period constraints with a search space of  10^957.
comp07 has 99 teachers,  77 curricula, 131 courses, 434 lectures, 25 periods, 20 rooms and  667 unavailable period constraints with a search space of 10^1171.
comp08 has 76 teachers,  61 curricula,  86 courses, 324 lectures, 25 periods, 18 rooms and  478 unavailable period constraints with a search space of  10^859.
comp09 has 68 teachers,  75 curricula,  76 courses, 279 lectures, 25 periods, 18 rooms and  405 unavailable period constraints with a search space of  10^740.
comp10 has 88 teachers,  67 curricula, 115 courses, 370 lectures, 25 periods, 18 rooms and  694 unavailable period constraints with a search space of  10^981.
comp11 has 24 teachers,  13 curricula,  30 courses, 162 lectures, 45 periods,  5 rooms and   94 unavailable period constraints with a search space of  10^381.
comp12 has 74 teachers, 150 curricula,  88 courses, 218 lectures, 36 periods, 11 rooms and 1368 unavailable period constraints with a search space of  10^566.
comp13 has 77 teachers,  66 curricula,  82 courses, 308 lectures, 25 periods, 19 rooms and  468 unavailable period constraints with a search space of  10^824.
comp14 has 68 teachers,  60 curricula,  85 courses, 275 lectures, 25 periods, 17 rooms and  486 unavailable period constraints with a search space of  10^722.

图 3.5. 域模型

为机器分配每个进程。所有进程已经有原始（未优化）分配。每个进程需要每个资源（如 CPU 或 RAM）的数量。这是 Cloud Balancing 示例的一个更为复杂的版本。

硬约束：

软限制：

这个问题由 Google ROADEF/EURO Challenge 定义，2012 年。

图 3.6. 价值主张

model_a1_1 has  2 resources,  1 neighborhoods,   4 locations,    4 machines,    79 services,   100 processes and 1 balancePenalties with a search space of     10^60.
model_a1_2 has  4 resources,  2 neighborhoods,   4 locations,  100 machines,   980 services,  1000 processes and 0 balancePenalties with a search space of   10^2000.
model_a1_3 has  3 resources,  5 neighborhoods,  25 locations,  100 machines,   216 services,  1000 processes and 0 balancePenalties with a search space of   10^2000.
model_a1_4 has  3 resources, 50 neighborhoods,  50 locations,   50 machines,   142 services,  1000 processes and 1 balancePenalties with a search space of   10^1698.
model_a1_5 has  4 resources,  2 neighborhoods,   4 locations,   12 machines,   981 services,  1000 processes and 1 balancePenalties with a search space of   10^1079.
model_a2_1 has  3 resources,  1 neighborhoods,   1 locations,  100 machines,  1000 services,  1000 processes and 0 balancePenalties with a search space of   10^2000.
model_a2_2 has 12 resources,  5 neighborhoods,  25 locations,  100 machines,   170 services,  1000 processes and 0 balancePenalties with a search space of   10^2000.
model_a2_3 has 12 resources,  5 neighborhoods,  25 locations,  100 machines,   129 services,  1000 processes and 0 balancePenalties with a search space of   10^2000.
model_a2_4 has 12 resources,  5 neighborhoods,  25 locations,   50 machines,   180 services,  1000 processes and 1 balancePenalties with a search space of   10^1698.
model_a2_5 has 12 resources,  5 neighborhoods,  25 locations,   50 machines,   153 services,  1000 processes and 0 balancePenalties with a search space of   10^1698.
model_b_1  has 12 resources,  5 neighborhoods,  10 locations,  100 machines,  2512 services,  5000 processes and 0 balancePenalties with a search space of  10^10000.
model_b_2  has 12 resources,  5 neighborhoods,  10 locations,  100 machines,  2462 services,  5000 processes and 1 balancePenalties with a search space of  10^10000.
model_b_3  has  6 resources,  5 neighborhoods,  10 locations,  100 machines, 15025 services, 20000 processes and 0 balancePenalties with a search space of  10^40000.
model_b_4  has  6 resources,  5 neighborhoods,  50 locations,  500 machines,  1732 services, 20000 processes and 1 balancePenalties with a search space of  10^53979.
model_b_5  has  6 resources,  5 neighborhoods,  10 locations,  100 machines, 35082 services, 40000 processes and 0 balancePenalties with a search space of  10^80000.
model_b_6  has  6 resources,  5 neighborhoods,  50 locations,  200 machines, 14680 services, 40000 processes and 1 balancePenalties with a search space of  10^92041.
model_b_7  has  6 resources,  5 neighborhoods,  50 locations, 4000 machines, 15050 services, 40000 processes and 1 balancePenalties with a search space of 10^144082.
model_b_8  has  3 resources,  5 neighborhoods,  10 locations,  100 machines, 45030 services, 50000 processes and 0 balancePenalties with a search space of 10^100000.
model_b_9  has  3 resources,  5 neighborhoods, 100 locations, 1000 machines,  4609 services, 50000 processes and 1 balancePenalties with a search space of 10^150000.
model_b_10 has  3 resources,  5 neighborhoods, 100 locations, 5000 machines,  4896 services, 50000 processes and 1 balancePenalties with a search space of 10^184948.

图 3.7. 域模型

使用车队车队，选择每个客户的对象并将其带给它。每个车块都可以为多个客户提供服务，但其容量有限。

除了基本情况(CVRP)外，还有一个包含时间窗(CVRPTW)的变体。

硬约束：

软限制：

VRP Web 定义了容量设施设施路由问题(CVRP)及其时间序列(CVRPTW)。

图 3.8. 价值主张

belgium-n50-k10             has  1 depots, 10 vehicles and   49 customers with a search space of   10^74.
belgium-n100-k10            has  1 depots, 10 vehicles and   99 customers with a search space of  10^170.
belgium-n500-k20            has  1 depots, 20 vehicles and  499 customers with a search space of 10^1168.
belgium-n1000-k20           has  1 depots, 20 vehicles and  999 customers with a search space of 10^2607.
belgium-n2750-k55           has  1 depots, 55 vehicles and 2749 customers with a search space of 10^8380.
belgium-road-km-n50-k10     has  1 depots, 10 vehicles and   49 customers with a search space of   10^74.
belgium-road-km-n100-k10    has  1 depots, 10 vehicles and   99 customers with a search space of  10^170.
belgium-road-km-n500-k20    has  1 depots, 20 vehicles and  499 customers with a search space of 10^1168.
belgium-road-km-n1000-k20   has  1 depots, 20 vehicles and  999 customers with a search space of 10^2607.
belgium-road-km-n2750-k55   has  1 depots, 55 vehicles and 2749 customers with a search space of 10^8380.
belgium-road-time-n50-k10   has  1 depots, 10 vehicles and   49 customers with a search space of   10^74.
belgium-road-time-n100-k10  has  1 depots, 10 vehicles and   99 customers with a search space of  10^170.
belgium-road-time-n500-k20  has  1 depots, 20 vehicles and  499 customers with a search space of 10^1168.
belgium-road-time-n1000-k20 has  1 depots, 20 vehicles and  999 customers with a search space of 10^2607.
belgium-road-time-n2750-k55 has  1 depots, 55 vehicles and 2749 customers with a search space of 10^8380.
belgium-d2-n50-k10          has  2 depots, 10 vehicles and   48 customers with a search space of   10^74.
belgium-d3-n100-k10         has  3 depots, 10 vehicles and   97 customers with a search space of  10^170.
belgium-d5-n500-k20         has  5 depots, 20 vehicles and  495 customers with a search space of 10^1168.
belgium-d8-n1000-k20        has  8 depots, 20 vehicles and  992 customers with a search space of 10^2607.
belgium-d10-n2750-k55       has 10 depots, 55 vehicles and 2740 customers with a search space of 10^8380.

A-n32-k5  has 1 depots,  5 vehicles and  31 customers with a search space of  10^40.
A-n33-k5  has 1 depots,  5 vehicles and  32 customers with a search space of  10^41.
A-n33-k6  has 1 depots,  6 vehicles and  32 customers with a search space of  10^42.
A-n34-k5  has 1 depots,  5 vehicles and  33 customers with a search space of  10^43.
A-n36-k5  has 1 depots,  5 vehicles and  35 customers with a search space of  10^46.
A-n37-k5  has 1 depots,  5 vehicles and  36 customers with a search space of  10^48.
A-n37-k6  has 1 depots,  6 vehicles and  36 customers with a search space of  10^49.
A-n38-k5  has 1 depots,  5 vehicles and  37 customers with a search space of  10^49.
A-n39-k5  has 1 depots,  5 vehicles and  38 customers with a search space of  10^51.
A-n39-k6  has 1 depots,  6 vehicles and  38 customers with a search space of  10^52.
A-n44-k7  has 1 depots,  7 vehicles and  43 customers with a search space of  10^61.
A-n45-k6  has 1 depots,  6 vehicles and  44 customers with a search space of  10^62.
A-n45-k7  has 1 depots,  7 vehicles and  44 customers with a search space of  10^63.
A-n46-k7  has 1 depots,  7 vehicles and  45 customers with a search space of  10^65.
A-n48-k7  has 1 depots,  7 vehicles and  47 customers with a search space of  10^68.
A-n53-k7  has 1 depots,  7 vehicles and  52 customers with a search space of  10^77.
A-n54-k7  has 1 depots,  7 vehicles and  53 customers with a search space of  10^79.
A-n55-k9  has 1 depots,  9 vehicles and  54 customers with a search space of  10^82.
A-n60-k9  has 1 depots,  9 vehicles and  59 customers with a search space of  10^91.
A-n61-k9  has 1 depots,  9 vehicles and  60 customers with a search space of  10^93.
A-n62-k8  has 1 depots,  8 vehicles and  61 customers with a search space of  10^94.
A-n63-k9  has 1 depots,  9 vehicles and  62 customers with a search space of  10^97.
A-n63-k10 has 1 depots, 10 vehicles and  62 customers with a search space of  10^98.
A-n64-k9  has 1 depots,  9 vehicles and  63 customers with a search space of  10^99.
A-n65-k9  has 1 depots,  9 vehicles and  64 customers with a search space of 10^101.
A-n69-k9  has 1 depots,  9 vehicles and  68 customers with a search space of 10^108.
A-n80-k10 has 1 depots, 10 vehicles and  79 customers with a search space of 10^130.
F-n45-k4  has 1 depots,  4 vehicles and  44 customers with a search space of  10^60.
F-n72-k4  has 1 depots,  4 vehicles and  71 customers with a search space of 10^108.
F-n135-k7 has 1 depots,  7 vehicles and 134 customers with a search space of 10^240.

CVRP 两个实例（带时间窗）：

belgium-tw-d2-n50-k10    has  2 depots, 10 vehicles and   48 customers with a search space of   10^74.
belgium-tw-d3-n100-k10   has  3 depots, 10 vehicles and   97 customers with a search space of  10^170.
belgium-tw-d5-n500-k20   has  5 depots, 20 vehicles and  495 customers with a search space of 10^1168.
belgium-tw-d8-n1000-k20  has  8 depots, 20 vehicles and  992 customers with a search space of 10^2607.
belgium-tw-d10-n2750-k55 has 10 depots, 55 vehicles and 2740 customers with a search space of 10^8380.
belgium-tw-n50-k10       has  1 depots, 10 vehicles and   49 customers with a search space of   10^74.
belgium-tw-n100-k10      has  1 depots, 10 vehicles and   99 customers with a search space of  10^170.
belgium-tw-n500-k20      has  1 depots, 20 vehicles and  499 customers with a search space of 10^1168.
belgium-tw-n1000-k20     has  1 depots, 20 vehicles and  999 customers with a search space of 10^2607.
belgium-tw-n2750-k55     has  1 depots, 55 vehicles and 2749 customers with a search space of 10^8380.

Solomon_025_C101       has 1 depots,  25 vehicles and   25 customers with a search space of   10^40.
Solomon_025_C201       has 1 depots,  25 vehicles and   25 customers with a search space of   10^40.
Solomon_025_R101       has 1 depots,  25 vehicles and   25 customers with a search space of   10^40.
Solomon_025_R201       has 1 depots,  25 vehicles and   25 customers with a search space of   10^40.
Solomon_025_RC101      has 1 depots,  25 vehicles and   25 customers with a search space of   10^40.
Solomon_025_RC201      has 1 depots,  25 vehicles and   25 customers with a search space of   10^40.
Solomon_100_C101       has 1 depots,  25 vehicles and  100 customers with a search space of  10^185.
Solomon_100_C201       has 1 depots,  25 vehicles and  100 customers with a search space of  10^185.
Solomon_100_R101       has 1 depots,  25 vehicles and  100 customers with a search space of  10^185.
Solomon_100_R201       has 1 depots,  25 vehicles and  100 customers with a search space of  10^185.
Solomon_100_RC101      has 1 depots,  25 vehicles and  100 customers with a search space of  10^185.
Solomon_100_RC201      has 1 depots,  25 vehicles and  100 customers with a search space of  10^185.
Homberger_0200_C1_2_1  has 1 depots,  50 vehicles and  200 customers with a search space of  10^429.
Homberger_0200_C2_2_1  has 1 depots,  50 vehicles and  200 customers with a search space of  10^429.
Homberger_0200_R1_2_1  has 1 depots,  50 vehicles and  200 customers with a search space of  10^429.
Homberger_0200_R2_2_1  has 1 depots,  50 vehicles and  200 customers with a search space of  10^429.
Homberger_0200_RC1_2_1 has 1 depots,  50 vehicles and  200 customers with a search space of  10^429.
Homberger_0200_RC2_2_1 has 1 depots,  50 vehicles and  200 customers with a search space of  10^429.
Homberger_0400_C1_4_1  has 1 depots, 100 vehicles and  400 customers with a search space of  10^978.
Homberger_0400_C2_4_1  has 1 depots, 100 vehicles and  400 customers with a search space of  10^978.
Homberger_0400_R1_4_1  has 1 depots, 100 vehicles and  400 customers with a search space of  10^978.
Homberger_0400_R2_4_1  has 1 depots, 100 vehicles and  400 customers with a search space of  10^978.
Homberger_0400_RC1_4_1 has 1 depots, 100 vehicles and  400 customers with a search space of  10^978.
Homberger_0400_RC2_4_1 has 1 depots, 100 vehicles and  400 customers with a search space of  10^978.
Homberger_0600_C1_6_1  has 1 depots, 150 vehicles and  600 customers with a search space of 10^1571.
Homberger_0600_C2_6_1  has 1 depots, 150 vehicles and  600 customers with a search space of 10^1571.
Homberger_0600_R1_6_1  has 1 depots, 150 vehicles and  600 customers with a search space of 10^1571.
Homberger_0600_R2_6_1  has 1 depots, 150 vehicles and  600 customers with a search space of 10^1571.
Homberger_0600_RC1_6_1 has 1 depots, 150 vehicles and  600 customers with a search space of 10^1571.
Homberger_0600_RC2_6_1 has 1 depots, 150 vehicles and  600 customers with a search space of 10^1571.
Homberger_0800_C1_8_1  has 1 depots, 200 vehicles and  800 customers with a search space of 10^2195.
Homberger_0800_C2_8_1  has 1 depots, 200 vehicles and  800 customers with a search space of 10^2195.
Homberger_0800_R1_8_1  has 1 depots, 200 vehicles and  800 customers with a search space of 10^2195.
Homberger_0800_R2_8_1  has 1 depots, 200 vehicles and  800 customers with a search space of 10^2195.
Homberger_0800_RC1_8_1 has 1 depots, 200 vehicles and  800 customers with a search space of 10^2195.
Homberger_0800_RC2_8_1 has 1 depots, 200 vehicles and  800 customers with a search space of 10^2195.
Homberger_1000_C110_1  has 1 depots, 250 vehicles and 1000 customers with a search space of 10^2840.
Homberger_1000_C210_1  has 1 depots, 250 vehicles and 1000 customers with a search space of 10^2840.
Homberger_1000_R110_1  has 1 depots, 250 vehicles and 1000 customers with a search space of 10^2840.
Homberger_1000_R210_1  has 1 depots, 250 vehicles and 1000 customers with a search space of 10^2840.
Homberger_1000_RC110_1 has 1 depots, 250 vehicles and 1000 customers with a search space of 10^2840.
Homberger_1000_RC210_1 has 1 depots, 250 vehicles and 1000 customers with a search space of 10^2840.

3.13.1. Vehicle 路由的域模型

使用时间窗域模型的载体路由大量使用 shadow 变量功能。这使得它能够更自然地表达其限制，因为 arrivalTime 和 departureTime 等属性可以在域模型上直接可用。

巴林林特利斯特利斯特区

在现实世界中，车辆不能直接跟随位置到位置：他们必须使用路路和高路。从业务的角度来说，这很重要：

对于优化算法，这并不重要，只要可以查找两个点之间的距离（并最好预先计算）。未来成本甚至不需要成为距离。它还可以是差时间、增加成本或更加权的功能。有几种方法可以预先计算出您的成本，如 GraphHopper （嵌入式、离线 Java 引擎）、Open MapQuest （Web 服务）和 Google Maps 客户端 API （Web 服务）。

还有一些技术 可以呈现它，例如针对开发人员的 Leaflet 和 Google Maps。

甚至可以使用 GraphHopper 或 Google Map Directions 呈现实际规划路由，但是由于路由在高路上的重叠，它可能会变得难以看到反引号：

请特别小心，在两个点之间采用与 OptaPlanner 中使用的相同优化标准。例如： GraphHopper 默认返回最快的路由，而不是最短的路由。不要使用 km（或 miles）最快的 GPS 路由来优化 OptaPlanner 中最短的差差：

与热门相对应，大多数用户都不希望最短的路由：他们想要使用最快的路由。它们比一般的路高。它们优先于有变化的障碍。在现实世界中，最快且最短的路由很少是相同的。

以时间和执行模式调度所有作业，以最小化项目延迟。每个作业都是项目的一部分。作业可以通过不同的方式执行：每个方法都是一种执行模式，它代表了不同的持续时间，但也可以使用不同的资源。这是一种灵活的 作业商店调度 的一种形式。

硬约束：

Medium 约束：

软限制：

该问题由 MISTA 2013 挑战 定义。

Schedule A-1  has  2 projects,  24 jobs,   64 execution modes,  7 resources and  150 resource requirements.
Schedule A-2  has  2 projects,  44 jobs,  124 execution modes,  7 resources and  420 resource requirements.
Schedule A-3  has  2 projects,  64 jobs,  184 execution modes,  7 resources and  630 resource requirements.
Schedule A-4  has  5 projects,  60 jobs,  160 execution modes, 16 resources and  390 resource requirements.
Schedule A-5  has  5 projects, 110 jobs,  310 execution modes, 16 resources and  900 resource requirements.
Schedule A-6  has  5 projects, 160 jobs,  460 execution modes, 16 resources and 1440 resource requirements.
Schedule A-7  has 10 projects, 120 jobs,  320 execution modes, 22 resources and  900 resource requirements.
Schedule A-8  has 10 projects, 220 jobs,  620 execution modes, 22 resources and 1860 resource requirements.
Schedule A-9  has 10 projects, 320 jobs,  920 execution modes, 31 resources and 2880 resource requirements.
Schedule A-10 has 10 projects, 320 jobs,  920 execution modes, 31 resources and 2970 resource requirements.
Schedule B-1  has 10 projects, 120 jobs,  320 execution modes, 31 resources and  900 resource requirements.
Schedule B-2  has 10 projects, 220 jobs,  620 execution modes, 22 resources and 1740 resource requirements.
Schedule B-3  has 10 projects, 320 jobs,  920 execution modes, 31 resources and 3060 resource requirements.
Schedule B-4  has 15 projects, 180 jobs,  480 execution modes, 46 resources and 1530 resource requirements.
Schedule B-5  has 15 projects, 330 jobs,  930 execution modes, 46 resources and 2760 resource requirements.
Schedule B-6  has 15 projects, 480 jobs, 1380 execution modes, 46 resources and 4500 resource requirements.
Schedule B-7  has 20 projects, 240 jobs,  640 execution modes, 61 resources and 1710 resource requirements.
Schedule B-8  has 20 projects, 440 jobs, 1240 execution modes, 42 resources and 3180 resource requirements.
Schedule B-9  has 20 projects, 640 jobs, 1840 execution modes, 61 resources and 5940 resource requirements.
Schedule B-10 has 20 projects, 460 jobs, 1300 execution modes, 42 resources and 4260 resource requirements.

将每个任务分配到员工队列中的 spot。每个任务都有一个持续时间，它受到员工的关联性级别的影响。

硬约束：

软级别 0 约束：

软级别 1 的限制：

软级别 2 约束：

软级别 3 的限制：

图 3.9. 价值主张

24tasks-8employees   has  24 tasks, 6 skills,  8 employees,   4 task types and  4 customers with a search space of   10^30.
50tasks-5employees   has  50 tasks, 5 skills,  5 employees,  10 task types and 10 customers with a search space of   10^69.
100tasks-5employees  has 100 tasks, 5 skills,  5 employees,  20 task types and 15 customers with a search space of  10^164.
500tasks-20employees has 500 tasks, 6 skills, 20 employees, 100 task types and 60 customers with a search space of 10^1168.

图 3.10. 域模型

将各考试安排为时段和上门。多个考试可以在同一期间内共享相同的空间。

硬约束：

软限制（其各自具有重要优势）：

它使用大量实时测试数据集。

这个问题由 国际时间选项卡 2007 年跟踪 1 定义。Geoffrey De Smet 在竞争中，使用非常早的 OptaPlanner 版本。然后，从那时起已进行了很多改进。

exam_comp_set1 has  7883 students,  607 exams, 54 periods,  7 rooms,  12 period constraints and  0 room constraints with a search space of 10^1564.
exam_comp_set2 has 12484 students,  870 exams, 40 periods, 49 rooms,  12 period constraints and  2 room constraints with a search space of 10^2864.
exam_comp_set3 has 16365 students,  934 exams, 36 periods, 48 rooms, 168 period constraints and 15 room constraints with a search space of 10^3023.
exam_comp_set4 has  4421 students,  273 exams, 21 periods,  1 rooms,  40 period constraints and  0 room constraints with a search space of  10^360.
exam_comp_set5 has  8719 students, 1018 exams, 42 periods,  3 rooms,  27 period constraints and  0 room constraints with a search space of 10^2138.
exam_comp_set6 has  7909 students,  242 exams, 16 periods,  8 rooms,  22 period constraints and  0 room constraints with a search space of  10^509.
exam_comp_set7 has 13795 students, 1096 exams, 80 periods, 15 rooms,  28 period constraints and  0 room constraints with a search space of 10^3374.
exam_comp_set8 has  7718 students,  598 exams, 80 periods,  8 rooms,  20 period constraints and  1 room constraints with a search space of 10^1678.

3.16.1. 用于考试时间设置的域模型

下图显示了考试的主要课程：

图 3.11. 检查域类图

请注意，我们已将考试概念分成 考试 课程和主题 课程。在解决过程中，考试 实例会改变（这是计划实体类），当它们的期间或房间属性改变时。主题、Period 和 Room 实例在解决过程中不会发生改变（它们有问题的事实，就像其他一些课程一样）。

对于每个转变，请安排相关变化。

硬约束：

软限制：

这个问题由 2010 年国际 Nurse Rosterionion 定义。

图 3.12. 价值主张

toy1          has 1 skills, 3 shiftTypes, 2 patterns, 1 contracts,  6 employees,  7 shiftDates,  35 shiftAssignments and   0 requests with a search space of   10^27.
toy2          has 1 skills, 3 shiftTypes, 3 patterns, 2 contracts, 20 employees, 28 shiftDates, 180 shiftAssignments and 140 requests with a search space of  10^234.

sprint01      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint02      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint03      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint04      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint05      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint06      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint07      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint08      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint09      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint10      has 1 skills, 4 shiftTypes, 3 patterns, 4 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_hint01 has 1 skills, 4 shiftTypes, 8 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_hint02 has 1 skills, 4 shiftTypes, 0 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_hint03 has 1 skills, 4 shiftTypes, 8 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_late01 has 1 skills, 4 shiftTypes, 8 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_late02 has 1 skills, 3 shiftTypes, 4 patterns, 3 contracts, 10 employees, 28 shiftDates, 144 shiftAssignments and 139 requests with a search space of  10^144.
sprint_late03 has 1 skills, 4 shiftTypes, 8 patterns, 3 contracts, 10 employees, 28 shiftDates, 160 shiftAssignments and 150 requests with a search space of  10^160.
sprint_late04 has 1 skills, 4 shiftTypes, 8 patterns, 3 contracts, 10 employees, 28 shiftDates, 160 shiftAssignments and 150 requests with a search space of  10^160.
sprint_late05 has 1 skills, 4 shiftTypes, 8 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_late06 has 1 skills, 4 shiftTypes, 0 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_late07 has 1 skills, 4 shiftTypes, 0 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.
sprint_late08 has 1 skills, 4 shiftTypes, 0 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and   0 requests with a search space of  10^152.
sprint_late09 has 1 skills, 4 shiftTypes, 0 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and   0 requests with a search space of  10^152.
sprint_late10 has 1 skills, 4 shiftTypes, 0 patterns, 3 contracts, 10 employees, 28 shiftDates, 152 shiftAssignments and 150 requests with a search space of  10^152.

medium01      has 1 skills, 4 shiftTypes, 0 patterns, 4 contracts, 31 employees, 28 shiftDates, 608 shiftAssignments and 403 requests with a search space of  10^906.
medium02      has 1 skills, 4 shiftTypes, 0 patterns, 4 contracts, 31 employees, 28 shiftDates, 608 shiftAssignments and 403 requests with a search space of  10^906.
medium03      has 1 skills, 4 shiftTypes, 0 patterns, 4 contracts, 31 employees, 28 shiftDates, 608 shiftAssignments and 403 requests with a search space of  10^906.
medium04      has 1 skills, 4 shiftTypes, 0 patterns, 4 contracts, 31 employees, 28 shiftDates, 608 shiftAssignments and 403 requests with a search space of  10^906.
medium05      has 1 skills, 4 shiftTypes, 0 patterns, 4 contracts, 31 employees, 28 shiftDates, 608 shiftAssignments and 403 requests with a search space of  10^906.
medium_hint01 has 1 skills, 4 shiftTypes, 7 patterns, 4 contracts, 30 employees, 28 shiftDates, 428 shiftAssignments and 390 requests with a search space of  10^632.
medium_hint02 has 1 skills, 4 shiftTypes, 7 patterns, 3 contracts, 30 employees, 28 shiftDates, 428 shiftAssignments and 390 requests with a search space of  10^632.
medium_hint03 has 1 skills, 4 shiftTypes, 7 patterns, 4 contracts, 30 employees, 28 shiftDates, 428 shiftAssignments and 390 requests with a search space of  10^632.
medium_late01 has 1 skills, 4 shiftTypes, 7 patterns, 4 contracts, 30 employees, 28 shiftDates, 424 shiftAssignments and 390 requests with a search space of  10^626.
medium_late02 has 1 skills, 4 shiftTypes, 7 patterns, 3 contracts, 30 employees, 28 shiftDates, 428 shiftAssignments and 390 requests with a search space of  10^632.
medium_late03 has 1 skills, 4 shiftTypes, 0 patterns, 4 contracts, 30 employees, 28 shiftDates, 428 shiftAssignments and 390 requests with a search space of  10^632.
medium_late04 has 1 skills, 4 shiftTypes, 7 patterns, 3 contracts, 30 employees, 28 shiftDates, 416 shiftAssignments and 390 requests with a search space of  10^614.
medium_late05 has 2 skills, 5 shiftTypes, 7 patterns, 4 contracts, 30 employees, 28 shiftDates, 452 shiftAssignments and 390 requests with a search space of  10^667.

long01        has 2 skills, 5 shiftTypes, 3 patterns, 3 contracts, 49 employees, 28 shiftDates, 740 shiftAssignments and 735 requests with a search space of 10^1250.
long02        has 2 skills, 5 shiftTypes, 3 patterns, 3 contracts, 49 employees, 28 shiftDates, 740 shiftAssignments and 735 requests with a search space of 10^1250.
long03        has 2 skills, 5 shiftTypes, 3 patterns, 3 contracts, 49 employees, 28 shiftDates, 740 shiftAssignments and 735 requests with a search space of 10^1250.
long04        has 2 skills, 5 shiftTypes, 3 patterns, 3 contracts, 49 employees, 28 shiftDates, 740 shiftAssignments and 735 requests with a search space of 10^1250.
long05        has 2 skills, 5 shiftTypes, 3 patterns, 3 contracts, 49 employees, 28 shiftDates, 740 shiftAssignments and 735 requests with a search space of 10^1250.
long_hint01   has 2 skills, 5 shiftTypes, 9 patterns, 3 contracts, 50 employees, 28 shiftDates, 740 shiftAssignments and   0 requests with a search space of 10^1257.
long_hint02   has 2 skills, 5 shiftTypes, 7 patterns, 3 contracts, 50 employees, 28 shiftDates, 740 shiftAssignments and   0 requests with a search space of 10^1257.
long_hint03   has 2 skills, 5 shiftTypes, 7 patterns, 3 contracts, 50 employees, 28 shiftDates, 740 shiftAssignments and   0 requests with a search space of 10^1257.
long_late01   has 2 skills, 5 shiftTypes, 9 patterns, 3 contracts, 50 employees, 28 shiftDates, 752 shiftAssignments and   0 requests with a search space of 10^1277.
long_late02   has 2 skills, 5 shiftTypes, 9 patterns, 4 contracts, 50 employees, 28 shiftDates, 752 shiftAssignments and   0 requests with a search space of 10^1277.
long_late03   has 2 skills, 5 shiftTypes, 9 patterns, 3 contracts, 50 employees, 28 shiftDates, 752 shiftAssignments and   0 requests with a search space of 10^1277.
long_late04   has 2 skills, 5 shiftTypes, 9 patterns, 4 contracts, 50 employees, 28 shiftDates, 752 shiftAssignments and   0 requests with a search space of 10^1277.
long_late05   has 2 skills, 5 shiftTypes, 9 patterns, 3 contracts, 50 employees, 28 shiftDates, 740 shiftAssignments and   0 requests with a search space of 10^1257.

图 3.13. 域模型

计划在 n 个团队数之间的匹配。

硬约束：

软限制：

在 Michael Trick 网站（其中包含世界记录） 上也定义了问题。

1-nl04     has  6 days,  4 teams and   12 matches with a search space of    10^5.
1-nl06     has 10 days,  6 teams and   30 matches with a search space of   10^19.
1-nl08     has 14 days,  8 teams and   56 matches with a search space of   10^43.
1-nl10     has 18 days, 10 teams and   90 matches with a search space of   10^79.
1-nl12     has 22 days, 12 teams and  132 matches with a search space of  10^126.
1-nl14     has 26 days, 14 teams and  182 matches with a search space of  10^186.
1-nl16     has 30 days, 16 teams and  240 matches with a search space of  10^259.
2-bra24    has 46 days, 24 teams and  552 matches with a search space of  10^692.
3-nfl16    has 30 days, 16 teams and  240 matches with a search space of  10^259.
3-nfl18    has 34 days, 18 teams and  306 matches with a search space of  10^346.
3-nfl20    has 38 days, 20 teams and  380 matches with a search space of  10^447.
3-nfl22    has 42 days, 22 teams and  462 matches with a search space of  10^562.
3-nfl24    has 46 days, 24 teams and  552 matches with a search space of  10^692.
3-nfl26    has 50 days, 26 teams and  650 matches with a search space of  10^838.
3-nfl28    has 54 days, 28 teams and  756 matches with a search space of  10^999.
3-nfl30    has 58 days, 30 teams and  870 matches with a search space of 10^1175.
3-nfl32    has 62 days, 32 teams and  992 matches with a search space of 10^1367.
4-super04  has  6 days,  4 teams and   12 matches with a search space of    10^5.
4-super06  has 10 days,  6 teams and   30 matches with a search space of   10^19.
4-super08  has 14 days,  8 teams and   56 matches with a search space of   10^43.
4-super10  has 18 days, 10 teams and   90 matches with a search space of   10^79.
4-super12  has 22 days, 12 teams and  132 matches with a search space of  10^126.
4-super14  has 26 days, 14 teams and  182 matches with a search space of  10^186.
5-galaxy04 has  6 days,  4 teams and   12 matches with a search space of    10^5.
5-galaxy06 has 10 days,  6 teams and   30 matches with a search space of   10^19.
5-galaxy08 has 14 days,  8 teams and   56 matches with a search space of   10^43.
5-galaxy10 has 18 days, 10 teams and   90 matches with a search space of   10^79.
5-galaxy12 has 22 days, 12 teams and  132 matches with a search space of  10^126.
5-galaxy14 has 26 days, 14 teams and  182 matches with a search space of  10^186.
5-galaxy16 has 30 days, 16 teams and  240 matches with a search space of  10^259.
5-galaxy18 has 34 days, 18 teams and  306 matches with a search space of  10^346.
5-galaxy20 has 38 days, 20 teams and  380 matches with a search space of  10^447.
5-galaxy22 has 42 days, 22 teams and  462 matches with a search space of  10^562.
5-galaxy24 has 46 days, 24 teams and  552 matches with a search space of  10^692.
5-galaxy26 has 50 days, 26 teams and  650 matches with a search space of  10^838.
5-galaxy28 has 54 days, 28 teams and  756 matches with a search space of  10^999.
5-galaxy30 has 58 days, 30 teams and  870 matches with a search space of 10^1175.
5-galaxy32 has 62 days, 32 teams and  992 matches with a search space of 10^1367.
5-galaxy34 has 66 days, 34 teams and 1122 matches with a search space of 10^1576.
5-galaxy36 has 70 days, 36 teams and 1260 matches with a search space of 10^1801.
5-galaxy38 has 74 days, 38 teams and 1406 matches with a search space of 10^2042.
5-galaxy40 has 78 days, 40 teams and 1560 matches with a search space of 10^2301.

以时间和方式调度所有任务，以最大程度降低电源成本。电源价格因时间而异。这是 作业权利调度的一种形式。

硬约束：

Medium 约束：

软限制（在原始问题定义中添加）:

这个问题由 ICON 质询 定义。

sample01   has 3 resources,   2 machines, 288 periods and   25 tasks with a search space of    10^53.
sample02   has 3 resources,   2 machines, 288 periods and   50 tasks with a search space of   10^114.
sample03   has 3 resources,   2 machines, 288 periods and  100 tasks with a search space of   10^226.
sample04   has 3 resources,   5 machines, 288 periods and  100 tasks with a search space of   10^266.
sample05   has 3 resources,   2 machines, 288 periods and  250 tasks with a search space of   10^584.
sample06   has 3 resources,   5 machines, 288 periods and  250 tasks with a search space of   10^673.
sample07   has 3 resources,   2 machines, 288 periods and 1000 tasks with a search space of  10^2388.
sample08   has 3 resources,   5 machines, 288 periods and 1000 tasks with a search space of  10^2748.
sample09   has 4 resources,  20 machines, 288 periods and 2000 tasks with a search space of  10^6668.
instance00 has 1 resources,  10 machines, 288 periods and  200 tasks with a search space of   10^595.
instance01 has 1 resources,  10 machines, 288 periods and  200 tasks with a search space of   10^599.
instance02 has 1 resources,  10 machines, 288 periods and  200 tasks with a search space of   10^599.
instance03 has 1 resources,  10 machines, 288 periods and  200 tasks with a search space of   10^591.
instance04 has 1 resources,  10 machines, 288 periods and  200 tasks with a search space of   10^590.
instance05 has 2 resources,  25 machines, 288 periods and  200 tasks with a search space of   10^667.
instance06 has 2 resources,  25 machines, 288 periods and  200 tasks with a search space of   10^660.
instance07 has 2 resources,  25 machines, 288 periods and  200 tasks with a search space of   10^662.
instance08 has 2 resources,  25 machines, 288 periods and  200 tasks with a search space of   10^651.
instance09 has 2 resources,  25 machines, 288 periods and  200 tasks with a search space of   10^659.
instance10 has 2 resources,  20 machines, 288 periods and  500 tasks with a search space of  10^1657.
instance11 has 2 resources,  20 machines, 288 periods and  500 tasks with a search space of  10^1644.
instance12 has 2 resources,  20 machines, 288 periods and  500 tasks with a search space of  10^1637.
instance13 has 2 resources,  20 machines, 288 periods and  500 tasks with a search space of  10^1659.
instance14 has 2 resources,  20 machines, 288 periods and  500 tasks with a search space of  10^1643.
instance15 has 3 resources,  40 machines, 288 periods and  500 tasks with a search space of  10^1782.
instance16 has 3 resources,  40 machines, 288 periods and  500 tasks with a search space of  10^1778.
instance17 has 3 resources,  40 machines, 288 periods and  500 tasks with a search space of  10^1764.
instance18 has 3 resources,  40 machines, 288 periods and  500 tasks with a search space of  10^1769.
instance19 has 3 resources,  40 machines, 288 periods and  500 tasks with a search space of  10^1778.
instance20 has 3 resources,  50 machines, 288 periods and 1000 tasks with a search space of  10^3689.
instance21 has 3 resources,  50 machines, 288 periods and 1000 tasks with a search space of  10^3678.
instance22 has 3 resources,  50 machines, 288 periods and 1000 tasks with a search space of  10^3706.
instance23 has 3 resources,  50 machines, 288 periods and 1000 tasks with a search space of  10^3676.
instance24 has 3 resources,  50 machines, 288 periods and 1000 tasks with a search space of  10^3681.
instance25 has 3 resources,  60 machines, 288 periods and 1000 tasks with a search space of  10^3774.
instance26 has 3 resources,  60 machines, 288 periods and 1000 tasks with a search space of  10^3737.
instance27 has 3 resources,  60 machines, 288 periods and 1000 tasks with a search space of  10^3744.
instance28 has 3 resources,  60 machines, 288 periods and 1000 tasks with a search space of  10^3731.
instance29 has 3 resources,  60 machines, 288 periods and 1000 tasks with a search space of  10^3746.
instance30 has 4 resources,  70 machines, 288 periods and 2000 tasks with a search space of  10^7718.
instance31 has 4 resources,  70 machines, 288 periods and 2000 tasks with a search space of  10^7740.
instance32 has 4 resources,  70 machines, 288 periods and 2000 tasks with a search space of  10^7686.
instance33 has 4 resources,  70 machines, 288 periods and 2000 tasks with a search space of  10^7672.
instance34 has 4 resources,  70 machines, 288 periods and 2000 tasks with a search space of  10^7695.
instance35 has 4 resources,  80 machines, 288 periods and 2000 tasks with a search space of  10^7807.
instance36 has 4 resources,  80 machines, 288 periods and 2000 tasks with a search space of  10^7814.
instance37 has 4 resources,  80 machines, 288 periods and 2000 tasks with a search space of  10^7764.
instance38 has 4 resources,  80 machines, 288 periods and 2000 tasks with a search space of  10^7736.
instance39 has 4 resources,  80 machines, 288 periods and 2000 tasks with a search space of  10^7783.
instance40 has 4 resources,  90 machines, 288 periods and 4000 tasks with a search space of 10^15976.
instance41 has 4 resources,  90 machines, 288 periods and 4000 tasks with a search space of 10^15935.
instance42 has 4 resources,  90 machines, 288 periods and 4000 tasks with a search space of 10^15887.
instance43 has 4 resources,  90 machines, 288 periods and 4000 tasks with a search space of 10^15896.
instance44 has 4 resources,  90 machines, 288 periods and 4000 tasks with a search space of 10^15885.
instance45 has 4 resources, 100 machines, 288 periods and 5000 tasks with a search space of 10^20173.
instance46 has 4 resources, 100 machines, 288 periods and 5000 tasks with a search space of 10^20132.
instance47 has 4 resources, 100 machines, 288 periods and 5000 tasks with a search space of 10^20126.
instance48 has 4 resources, 100 machines, 288 periods and 5000 tasks with a search space of 10^20110.
instance49 has 4 resources, 100 machines, 288 periods and 5000 tasks with a search space of 10^20078.

决定在每个资产类投资的相对数量。

硬约束：

软限制：

de_smet_1 has 1 regions, 3 sectors and 11 asset classes with a search space of 10^4.
irrinki_1 has 2 regions, 3 sectors and 6 asset classes with a search space of 10^3.

较大的数据集尚未创建或测试，但不应构成问题。好的数据来源是 这一资产关联网站。

将每个会议分配给一个小时和房间。Timeslots 可能会重叠。在 *.xlsx 文件中读取和写入，该文件可使用 libreoffice 或 Excel 编辑。

硬约束：

软限制：

图 3.14. 价值主张

18talks-6timeslots-5rooms    has  18 talks,  6 timeslots and  5 rooms with a search space of  10^26.
36talks-12timeslots-5rooms   has  36 talks, 12 timeslots and  5 rooms with a search space of  10^64.
72talks-12timeslots-10rooms  has  72 talks, 12 timeslots and 10 rooms with a search space of 10^149.
108talks-18timeslots-10rooms has 108 talks, 18 timeslots and 10 rooms with a search space of 10^243.
216talks-18timeslots-20rooms has 216 talks, 18 timeslots and 20 rooms with a search space of 10^552.

从展到演示到展示的车车，但计划仅显示可用日。

硬约束：

Medium 约束：

软限制：

47shows has 47 shows with a search space of 10^59.

为试点和航班出员指派航班。

硬约束：

软限制：

175flights-7days-Europe  has 2 skills, 50 airports, 150 employees, 175 flights and  875 flight assignments with a search space of  10^1904.
700flights-28days-Europe has 2 skills, 50 airports, 150 employees, 700 flights and 3500 flight assignments with a search space of  10^7616.
875flights-7days-Europe  has 2 skills, 50 airports, 750 employees, 875 flights and 4375 flight assignments with a search space of 10^12578.
175flights-7days-US      has 2 skills, 48 airports, 150 employees, 175 flights and  875 flight assignments with a search space of  10^1904.

红帽构建的 OptaPlanner 包含多个示例，演示各种计划用例。下载并使用示例来探索不同类型的规划解决方案。

如果您使用集成开发环境(IDE)，如 IntelliJ、Eclipse 或 Netbeans，您可以在开发环境中运行下载的 OptaPlanner 示例。

Business Central 包括很多可用于熟悉产品和其功能的示例项目。员工的 rostering 示例项目经过设计和创建，以展示红帽构建 OptaPlanner 的变速用例。使用以下步骤部署和运行 Business Central 中的员工降级示例。

本文档的其余部分介绍了各个项目资产及其配置。

员工的 rostering 示例项目是 Business Central 中提供的一个预配置的项目。您可以在 第 5.1 节 “在 Business Central 中部署 employees rostering 示例项目” 中了解如何部署此项目。

您可以创建员工的名册示例"全新"。您可以使用本例中的工作流在 Business Central 中创建您自己的类似项目。

package

import

function  // Optional

query  // Optional

declare   // Optional

global   // Optional

rule "rule name"
    // Attributes
    when
        // Conditions
    then
        // Actions
end

rule "rule2 name"

...

rule "Underage"
  salience 15
  agenda-group "applicationGroup"
  when
    $application : LoanApplication()
    Applicant( age < 21 )
  then
    $application.setApproved( false );
    $application.setExplanation( "Underage" );
end

5.2.5. 使用指导规则为员工名单创建规则

您可以使用 Business Central 中的指导规则设计人员创建为员工名单定义硬和软约束的规则。

5.2.5.1. 指导规则

指导规则是您通过规则创建在业务中心基于 UI 的指导规则设计者中创建的业务规则。指导规则设计器根据所定义规则的数据对象，提供可接受输入的字段和选项。您定义的指南规则与所有其他规则资产一样编译为 Drools Rule Language(DRL)规则。

与指导规则相关的所有数据对象都必须位于与指导规则相同的项目软件包中。默认导入同一软件包中的资产。创建必要的数据对象和指导规则后，您可以使用指南规则设计器的 Data Objects 选项卡来验证所有所需数据对象是否已列出或导入其他现有数据对象，方法是添加新项目。

5.2.5.2. 创建用于平衡员工切换数量的指导规则

BalanceEmployeesShiftNumber 指导规则创建一个软约束，确保以尽可能均匀地平衡的方式为员工分配切换。它通过创建一个分数影响，在变送变小时增加。分数公式由规则实施，使 Solver 以更均衡的方式分发转换。

流程

1. 在 Business Central 中，前往 Menu → Design → Projects 并点项目名称。
2. 点 Add Asset → Guided Rule。
3. 输入 BalanceEmployeesShiftNumber 作为 引导规则 名称，再选择 employees rostering.employeerostering 软件包。
4. 点 Ok 创建规则资产。
5. 点 WHEN 字段中的 来添加 WHEN 条件。
6. 在规则窗口的 Add a 条件 中选择 Employee。单击 +Ok。
7. 单击 Employee 条件来修改限制，并添加变量名称 $employee。

8. 添加来自 加速 的 WHEN 条件。

   1. 在 From Accumulate 条件 上方点击 添加模式 并选择 Number 作为事实类型，从下拉列表中选择 Number。
   2. 将变量名称 $shiftCount 添加到 Number 条件中。
   3. 在 From Accumulate 条件下，单击添加模式，然后从下拉列表中选择 ShiftAssignment fact 类型。
   4. 将变量名称 $shiftAssignment 添加到 ShiftAssignment fact 类型。
   5. 再次单击 ShiftAssignment 条件，然后从 Add a restrictions on a field 下拉列表中选择 employees。
   6. 从 employees 约束旁边的下拉列表中选择 等于。
   7. 点击下拉按钮旁的 图标添加变量，然后点击 Field value 窗口中的 Bound 变量。
   8. 从下拉列表中选择 $employee。
   9. 在 Function 框中，键入 count($shiftAssignment)。
9. 点 wordpress N 字段中的 来添加 wordpressN 条件。

10. 在 Add a new action 窗口中选择 Modify Soft Score。单击 +Ok。

    1. 在方框中输入以下表达式： -（$shiftCount.intValue（）*$shiftCount.intValue（））
11. 单击右上角的 Validate 来检查所有规则条件是否有效。如果规则验证失败，解决错误消息中描述的任何问题，查看规则中的所有组件，然后重试验证规则直到规则通过为止。
12. 单击 Save 以保存该规则。

有关创建指南规则的更多信息，请参阅使用指导规则 设计决策服务。

5.2.5.3. 为每天不一换个变化创建指导规则

OneEmployeeShiftPerDay 指导规则创建了一个硬约束，员工不会超过一天的转变。在员工指定示例中，这个约束是使用指导的规则设计人员创建的。

流程

1. 在 Business Central 中，前往 Menu → Design → Projects 并点项目名称。
2. 点 Add Asset → Guided Rule。
3. 输入 OneEmployeeShiftPerDay 作为 引导规则 名称，再选择 employees rostering.employeerostering 软件包。
4. 点 Ok 创建规则资产。
5. 点 WHEN 字段中的 来添加 WHEN 条件。
6. 从 Add a condition to rule 窗口中选择 Free form DRL。

7. 在自由表单 DRL 框中，输入以下条件：

   $shiftAssignment : ShiftAssignment( employee != null )
   		ShiftAssignment( this != $shiftAssignment , employee == $shiftAssignment.employee , shift.timeslot.startTime.toLocalDate() == $shiftAssignment.shift.timeslot.startTime.toLocalDate() )

   此条件指出，不能分配给已经在同一天进行另一个切换分配的员工。

8. 点 wordpress N 字段中的 来添加 wordpressN 条件。
9. 从 Add a new action 窗口中选择 Add free form DRL。

10. 在自由表单 DRL 框中，输入以下条件：

    scoreHolder.addHardConstraintMatch(kcontext, -1);

11. 单击右上角的 Validate 来检查所有规则条件是否有效。如果规则验证失败，解决错误消息中描述的任何问题，查看规则中的所有组件，然后重试验证规则直到规则通过为止。
12. 单击 Save 以保存该规则。

有关创建指南规则的更多信息，请参阅使用指导规则 设计决策服务。

5.2.5.4. 创建一条指导规则以满足不断变化的要求技能

ShiftReqiredSkillsAreMet guided 规则创建了一个硬约束，以确保所有转换都被分配了一组正确技能的员工。在员工指定示例中，这个约束是使用指导的规则设计人员创建的。

流程

1. 在 Business Central 中，前往 Menu → Design → Projects 并点项目名称。
2. 点 Add Asset → Guided Rule。
3. 输入 ShiftReqiredSkillsAreMet 作为 引导规则 名称并选择 employees rostering.employeerostering 软件包。
4. 点 Ok 创建规则资产。
5. 点 WHEN 字段中的 来添加 WHEN 条件。
6. 选择 Add a condition to rule 窗口中的 ShiftAssignment。单击 +Ok。
7. 单击 ShiftAssignment 条件，然后从 Add a limits on a field 下拉列表中选择 employees。
8. 在设计人员中，单击 员工 旁边的下拉列表，然后选择 不是 null。

9. 单击 ShiftAssignment 条件，然后单击 Expression 编辑器。

   1. 在设计人员中，单击 [not bound] 以打开 Expression 编辑器，并将表达式绑定到变量 $requiredSkill。点 Set。
   2. 在设计人员（ /requiredSkill 旁边），从第一个下拉列表中选择 转换，然后从下一下拉列表中选择 requiredSkill。

10. 单击 ShiftAssignment 条件，然后单击 Expression 编辑器。

    1. 在设计人员（ [not bound] 旁边），从第一个下拉列表中选择 员工，然后从下一下拉列表中选择 技能。
    2. 将下一个下拉列表保留为 选择。
    3. 在下一个下拉菜单中，请更改 以排除 。
    4. 点击 排除 的 图标，在 Field value 窗口中点击 New formula 按钮。
    5. 在公式框中输入 $requiredSkill。
11. 点 wordpress N 字段中的 来添加 wordpressN 条件。
12. 在 Add a new action 窗口中选择 Modify Hard Score。单击 +Ok。
13. 在分数操作框中输入 -1。
14. 单击右上角的 Validate 来检查所有规则条件是否有效。如果规则验证失败，解决错误消息中描述的任何问题，查看规则中的所有组件，然后重试验证规则直到规则通过为止。
15. 单击 Save 以保存该规则。

有关创建指南规则的更多信息，请参阅使用指导规则 设计决策服务。

5.2.5.5. 创建用于管理开箱即用请求的指南规则

DayOffRequest guided 规则会创建一个软约束。如果最初被分配了该转换的人，则这个限制可以重新分配给另一位员工。在员工指定示例中，这个约束是使用指导的规则设计人员创建的。

流程

1. 在 Business Central 中，前往 Menu → Design → Projects 并点项目名称。
2. 点 Add Asset → Guided Rule。
3. 输入 DayOffRequest 作为 引导规则 名称，再选择 employees rostering.employeerostering 软件包。
4. 点 Ok 创建规则资产。
5. 点 WHEN 字段中的 来添加 WHEN 条件。
6. 从 Add a condition to rule 窗口中选择 Free form DRL。

7. 在自由表单 DRL 框中，输入以下条件：

   $dayOffRequest : DayOffRequest( )
   		ShiftAssignment( employee == $dayOffRequest.employee , shift.timeslot.startTime.toLocalDate() == $dayOffRequest.date )

   如果转移被分配给一个进行当天发出的某个员工，则该条件将指出，该条件可以取消对当天的转换进行取消签名。

8. 点 wordpress N 字段中的 来添加 wordpressN 条件。
9. 从 Add a new action 窗口中选择 Add free form DRL。

10. 在自由表单 DRL 框中，输入以下条件：

    scoreHolder.addSoftConstraintMatch(kcontext, -100);

11. 单击右上角的 Validate 来检查所有规则条件是否有效。如果规则验证失败，解决错误消息中描述的任何问题，查看规则中的所有组件，然后重试验证规则直到规则通过为止。
12. 单击 Save 以保存该规则。

有关创建指南规则的更多信息，请参阅使用指导规则 设计决策服务。

在部署或重新创建示例地址后，您可以使用 REST API 访问它。

您必须使用 REST API 注册解决器实例。然后，您可以提供数据集并检索优化的解决方案。

Apache Maven 是 Java 应用程序开发中使用的分布式构建自动化工具，用于创建、管理和构建软件项目。Maven 使用名为 Project Object Model(POM)文件的标准配置文件来定义项目并管理构建流程。POM 文件描述使用 XML 文件生成的项目打包和输出的模块和组件依赖关系、构建顺序和目标。这可确保以正确、一致的方式构建项目。

您可以将在线 Maven 存储库与 Quarkus 项目一起使用，也可以下载红帽 Quarkus Maven 存储库构建。

您可以使用 Apache Maven 和 Quarkus Maven 插件，使用红帽构建的 OptaPlanner 和 Quarkus 应用程序启动并运行。

您可以使用 code.quarkus.redhat.com 网站生成红帽构建的 OptaPlanner Quarkus Maven 项目，并自动添加并配置要在应用程序中使用的扩展。另外，code.quarkus.redhat.com 会自动管理将项目编译到原生可执行文件所需的配置参数。

本节介绍了如何生成 OptaPlanner Maven 项目并包含以下主题：

您可以使用 Quarkus 命令行界面(CLI)创建 Quarkus OptaPlanner 项目。

您可以使用 XML 文件配置解决器。在遵循 Maven 目录结构的典型项目中，在构建带有 SolverFactory 的 Solver Factory 后，address rConfig XML 文件位于 $PROJECT_DIR/src/main/resources/org/optaplanner/examples/<PROJECT>/solver 目录，其中 & lt;PROJECT > 是 OptaPlanner 项目的名称。或者，也可以通过 SolverFactory .createFromXmlFile（）从文件创建一个 SolververFactory。但是，出于便携性的原因，建议使用 classpath 资源。

Solver 和 SolverFactory 都有一个名为 Solution_ 的通用类型，它是代表规划问题和解决方案的类。

OptaPlanner 通过更改配置相对容易地切换优化算法。

您可以使用 SolverConfig API 配置一个临时解决方案。这在运行时动态更改值特别有用。以下示例在 NQueens 项目中构建 Solver 之前，会根据系统属性更改正在运行的时间：

        SolverConfig solverConfig = SolverConfig.createFromXmlResource(
                "org/optaplanner/examples/nqueens/solver/nqueensSolverConfig.xml");
        solverConfig.withTerminationConfig(new TerminationConfig()
                        .withMinutesSpentLimit(userInput));

        SolverFactory<NQueens> solverFactory = SolverFactory.create(solverConfig);
        Solver<NQueens> solver = solverFactory.buildSolver();

解决器配置 XML 文件中的每个元素都作为软件包命名空间 org.optaplanner.core.config 中的 Config 类或一个属性提供。这些配置 类是 XML 格式的 Java 表示。它们构建软件包命名空间的运行时组件 org.optaplanner.core.impl.，并将它们汇编为有效的 Solver。

    private SolverConfig template;

    public void init() {
        template = SolverConfig.createFromXmlResource(
                "org/optaplanner/examples/nqueens/solver/nqueensSolverConfig.xml");
        template.setTerminationConfig(new TerminationConfig());
    }

    // Called concurrently from different threads
    public void userRequest(..., long userInput) {
        SolverConfig solverConfig = new SolverConfig(template); // Copy it
        solverConfig.getTerminationConfig().setMinutesSpentLimit(userInput);
        SolverFactory<NQueens> solverFactory = SolverFactory.create(solverConfig);
        Solver<NQueens> solver = solverFactory.buildSolver();
        ...
    }

您必须指定域模型中的哪些类是规划实体、哪些属性是计划变量等。使用以下方法之一在 OptaPlanner 项目中添加注解：

默认情况下，OptaPlanner 使用反射访问您的域。与直接访问相比，反射比较可靠，但速度慢。另外，您还可以使用 Gizmo 将 OptaPlanner 配置为访问您的域，这将生成字节码来直接访问您的域的字段和方法，而无需反映。但是，此方法有以下限制：

  <solver>
    <domainAccessType>GIZMO</domainAccessType>
  </solver>

在 OptaPlanner 项目中，您可以添加自定义属性来解决配置元素，这些元素实例化类，并明确提及自定义属性的文档。

使用解决方法解决规划问题。

以下示例解决了 NQueens 问题：

    NQueens problem = ...;
    NQueens bestSolution = solver.solve(problem);

在本示例中，solution （） 方法会返回一个 NQueens 实例，并且每个 Queen 分配给 行。

图 8.1. 8ms 中的 Four Queens Puzzle best Solution(Also a Optimal Solution)

解决(Solution) 方法可能需要很长时间，具体要看问题的大小和解决方法配置。Solver 智能地处理可能解决方案的搜索空间，并记住在解决过程中遇到的最佳解决方案。根据很多因素，包括问题的大小、Solver 的时间、解决器配置等等，最佳解决方案 可能是或可能不是最佳解决方案。

解决方案环境模式允许您检测实施中的常见错误。它不会影响日志级别。

寻址程序只有一个随机实例。有些解决方法配置使用随机实例，其随机实例数量不止于其他实例。例如，Simulated Anneing 算法依赖于随机数字，而 Tabu Search 仅依赖于它解析分数绑定。环境模式会影响该随机实例的影响。

您可以在解决器配置 XML 文件中设置环境模式。以下示例设置了 FAST_ASSERT 模式：

<solver xmlns="https://www.optaplanner.org/xsd/solver" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://www.optaplanner.org/xsd/solver https://www.optaplanner.org/xsd/solver/solver.xsd">
  <environmentMode>FAST_ASSERT</environmentMode>
  ...
</solver>

您可以在 OptaPlanner solver 中更改日志记录级别，以查看解决器活动。以下列表描述了不同的日志记录级别：

以下示例显示了 debug 日志记录的输出：

INFO  Solving started: time spent (3), best score (-4init/0), random (JDK with seed 0).
DEBUG     CH step (0), time spent (5), score (-3init/0), selected move count (1), picked move (Queen-2 {null -> Row-0}).
DEBUG     CH step (1), time spent (7), score (-2init/0), selected move count (3), picked move (Queen-1 {null -> Row-2}).
DEBUG     CH step (2), time spent (10), score (-1init/0), selected move count (4), picked move (Queen-3 {null -> Row-3}).
DEBUG     CH step (3), time spent (12), score (-1), selected move count (4), picked move (Queen-0 {null -> Row-1}).
INFO  Construction Heuristic phase (0) ended: time spent (12), best score (-1), score calculation speed (9000/sec), step total (4).
DEBUG     LS step (0), time spent (19), score (-1),     best score (-1), accepted/selected move count (12/12), picked move (Queen-1 {Row-2 -> Row-3}).
DEBUG     LS step (1), time spent (24), score (0), new best score (0), accepted/selected move count (9/12), picked move (Queen-3 {Row-3 -> Row-2}).
INFO  Local Search phase (1) ended: time spent (24), best score (0), score calculation speed (4000/sec), step total (2).
INFO  Solving ended: time spent (24), best score (0), score calculation speed (7000/sec), phase total (2), environment mode (REPRODUCIBLE).

所有消耗值的时间都为毫秒。

所有内容都记录到 SLF4J，它是一个简单的日志 facade，它将每个日志消息委派给 Logback、Apache Commons Logging、Log4j 或 java.util.logging。为您选择的日志记录框架添加依赖项到日志适应器。

Logback 是推荐的日志框架，用于 OptaPlanner。使用 Logback 记录 OptaPlanner solver 活动。

如果您已经使用 Log4J，且您不想切换到更快速的后续后继而使用 Log4J，您可以为 Log4J 配置 OptaPlanner 项目。

OptaPlanner 通过 Micrometer 公开指标数据，这是 Java 应用程序的指标检测库。您可以将 Micrometer 与流行监控系统一起使用来监控 OptaPlanner solver。

<solver xmlns="https://www.optaplanner.org/xsd/solver" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="https://www.optaplanner.org/xsd/solver https://www.optaplanner.org/xsd/solver/solver.xsd">
  <monitoring>
    <metric>BEST_SCORE</metric>
    <metric>SCORE_CALCULATION_COUNT</metric>
    ...
  </monitoring>
  ...
</solver>

许多 heuristics 和 metaheuristics 依赖于伪随机数字生成器来移动选择，以解决分数绑定、根据移动接受度等问题。在解决过程中，使用相同的随机实例可以重复使用，以提高随机值的可重复性、性能和统一分布。

随机 seed 是一个数字，用于初始化伪随机数字生成器。

在大多数情况下，randomType 属性的值对多个数据集最佳解决方案的平均质量没有重大影响。

批量解决问题正在并行解决多个数据集。批量解决问题尤其有用：

public class TimeTableService {

    private SolverManager<TimeTable, Long> solverManager;

    // Returns immediately, call it for every data set
    public void solveBatch(Long timeTableId) {
        solverManager.solve(timeTableId,
                // Called once, when solving starts
                this::findById,
                // Called once, when solving ends
                this::save);
    }

    public TimeTable findById(Long timeTableId) {...}

    public void save(TimeTable timeTable) {...}

}

当用户等待某个解决方案时，当解决问题时，可能需要等待几分钟或几小时后才会收到结果。为确保一切顺利的用户，通过显示最佳解决方案以及目前获得的最佳分数来显示进度。

您可以使用 Apache Maven 和 Quarkus Maven 插件，使用红帽构建的 OptaPlanner 和 Quarkus 应用程序启动并运行。

红帽构建的 OptaPlanner 时间表项目的目标是将每节分配给一个时间段和一个房间。为此，请添加三个类： Timeslot、Lesson 和 Room，如下图所示：

时间段没有日期，因为高校的计划只每周重复。无法进行持续 规划。次性被称为 问题事实，因为在解决过程中不会有定时实例变化。此类类不需要任何特定于 OptaPlanner 的注解。

房间 实例在解决过程中不会改变，因此 Room 也是 问题。

在寻求过程中，OptaPlanner 改变了 lesson 类的 timelot 和 room 字段，从而将每个较小的时间分配给一个时间段和一个房间。 因为 OptaPlanner 更改了这些字段，所以 lesson 是一个 规划实体 ：

上图中的大多数字段包含输入数据，但 orange 字段除外。在输入数据中 未分配的 时间和房间 字段(null)，并在输出数据中分配（而不是 null）。OptaPlanner 在解决过程中更改这些字段。这些字段称为规划变量。为了 OptaPlanner 可以识别它们，timelot 和 room 字段都需要 @PlanningVariable 注解。它们包含类( Lesson )需要 @PlanningEntity 注释。

当解决问题时，分数 代表特定解决方案的质量。得分越高。红帽构建的 OptaPlanner 寻找最佳解决方案，这是可用时间获得最高分数的解决方案。这可能是 最佳解决方案。

因为可时间的示例用例具有硬和软约束，因此请使用 HardSoftScore 类来代表分数：

硬约束的加法是相对于其他硬约束的权重。软限制会高于其他软限制。硬限制始终大于软限制，无论其对应的权重如何。

要计算分数，您可以实施 EasyScoreCalculator 类：

public class TimeTableEasyScoreCalculator implements EasyScoreCalculator<TimeTable> {

    @Override
    public HardSoftScore calculateScore(TimeTable timeTable) {
        List<Lesson> lessonList = timeTable.getLessonList();
        int hardScore = 0;
        for (Lesson a : lessonList) {
            for (Lesson b : lessonList) {
                if (a.getTimeslot() != null && a.getTimeslot().equals(b.getTimeslot())
                        && a.getId() < b.getId()) {
                    // A room can accommodate at most one lesson at the same time.
                    if (a.getRoom() != null && a.getRoom().equals(b.getRoom())) {
                        hardScore--;
                    }
                    // A teacher can teach at most one lesson at the same time.
                    if (a.getTeacher().equals(b.getTeacher())) {
                        hardScore--;
                    }
                    // A student can attend at most one lesson at the same time.
                    if (a.getStudentGroup().equals(b.getStudentGroup())) {
                        hardScore--;
                    }
                }
            }
        }
        int softScore = 0;
        // Soft constraints are only implemented in the "complete" implementation
        return HardSoftScore.of(hardScore, softScore);
    }

}

不幸的是，这个解决方案无法进行很好的扩展，因为它是非增量：每次分配给不同的时间段或房间，都会重新评估所有课程来计算新分数。

更好的解决方法是创建一个 src/main/java/com/example/solver/TimeTableConstraintProvider.java 类来执行增量分数计算。此类使用 OptaPlanner 的 ConstraintStream API，它由 Java 8 Streams 和 SQL 产生。ConstraintProvider 缩放比 EasyScoreCalculator 更好的度量：O(n)而不是 O(n)。

package com.example.solver;

import com.example.domain.Lesson;
import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
import org.optaplanner.core.api.score.stream.Constraint;
import org.optaplanner.core.api.score.stream.ConstraintFactory;
import org.optaplanner.core.api.score.stream.ConstraintProvider;
import org.optaplanner.core.api.score.stream.Joiners;

public class TimeTableConstraintProvider implements ConstraintProvider {

    @Override
    public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
        return new Constraint[] {
                // Hard constraints
                roomConflict(constraintFactory),
                teacherConflict(constraintFactory),
                studentGroupConflict(constraintFactory),
                // Soft constraints are only implemented in the "complete" implementation
        };
    }

    private Constraint roomConflict(ConstraintFactory constraintFactory) {
        // A room can accommodate at most one lesson at the same time.

        // Select a lesson ...
        return constraintFactory.from(Lesson.class)
                // ... and pair it with another lesson ...
                .join(Lesson.class,
                        // ... in the same timeslot ...
                        Joiners.equal(Lesson::getTimeslot),
                        // ... in the same room ...
                        Joiners.equal(Lesson::getRoom),
                        // ... and the pair is unique (different id, no reverse pairs)
                        Joiners.lessThan(Lesson::getId))
                // then penalize each pair with a hard weight.
                .penalize("Room conflict", HardSoftScore.ONE_HARD);
    }

    private Constraint teacherConflict(ConstraintFactory constraintFactory) {
        // A teacher can teach at most one lesson at the same time.
        return constraintFactory.from(Lesson.class)
                .join(Lesson.class,
                        Joiners.equal(Lesson::getTimeslot),
                        Joiners.equal(Lesson::getTeacher),
                        Joiners.lessThan(Lesson::getId))
                .penalize("Teacher conflict", HardSoftScore.ONE_HARD);
    }

    private Constraint studentGroupConflict(ConstraintFactory constraintFactory) {
        // A student can attend at most one lesson at the same time.
        return constraintFactory.from(Lesson.class)
                .join(Lesson.class,
                        Joiners.equal(Lesson::getTimeslot),
                        Joiners.equal(Lesson::getStudentGroup),
                        Joiners.lessThan(Lesson::getId))
                .penalize("Student group conflict", HardSoftScore.ONE_HARD);
    }

}

TimeTable 实例嵌套了单个 dataset 的所有 Timeslot、Room 和 Lesson 实例。另外，由于它包含了 allon，每个都具有特定规划变量状态，所以它是一个 规划解决方案，并有分数：

TimeTable 类有一个 @PlanningSolution 注释，因此红帽构建的 OptaPlanner 知道该类包含所有输入和输出数据。

具体来说，这个类是问题的输入：

但是，这个类也是解决方案的输出：

package com.example.domain;

import java.util.List;

import org.optaplanner.core.api.domain.solution.PlanningEntityCollectionProperty;
import org.optaplanner.core.api.domain.solution.PlanningScore;
import org.optaplanner.core.api.domain.solution.PlanningSolution;
import org.optaplanner.core.api.domain.solution.ProblemFactCollectionProperty;
import org.optaplanner.core.api.domain.valuerange.ValueRangeProvider;
import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;

@PlanningSolution
public class TimeTable {

    @ValueRangeProvider(id = "timeslotRange")
    @ProblemFactCollectionProperty
    private List<Timeslot> timeslotList;

    @ValueRangeProvider(id = "roomRange")
    @ProblemFactCollectionProperty
    private List<Room> roomList;

    @PlanningEntityCollectionProperty
    private List<Lesson> lessonList;

    @PlanningScore
    private HardSoftScore score;

    private TimeTable() {
    }

    public TimeTable(List<Timeslot> timeslotList, List<Room> roomList,
            List<Lesson> lessonList) {
        this.timeslotList = timeslotList;
        this.roomList = roomList;
        this.lessonList = lessonList;
    }

    // ********************************
    // Getters and setters
    // ********************************

    public List<Timeslot> getTimeslotList() {
        return timeslotList;
    }

    public List<Room> getRoomList() {
        return roomList;
    }

    public List<Lesson> getLessonList() {
        return lessonList;
    }

    public HardSoftScore getScore() {
        return score;
    }

}

遵循相同的逻辑，roomList 字段也有 @ValueRangeProvider 注释。

time lotList 和 roomList 字段具有 @ProblemFactCollectionProperty 注释，因此您的 TimeTableConstraintProvider 可以从这些实例中进行选择。

lessonList 有一个 @PlanningEntityCollectionProperty 注解，因此 OptaPlanner 可在解决过程中更改它们，并且您的 TimeTableConstraintProvider 也可从那些中选择。

解决 REST 线程中的规划问题会导致 HTTP 超时问题。因此，Quarkus 扩展注入 SolverManager，它会在单独的线程池中运行 solvers，并可并行处理多个数据集。

package org.acme.optaplanner.rest;

import java.util.UUID;
import java.util.concurrent.ExecutionException;
import javax.inject.Inject;
import javax.ws.rs.POST;
import javax.ws.rs.Path;

import org.acme.optaplanner.domain.TimeTable;
import org.optaplanner.core.api.solver.SolverJob;
import org.optaplanner.core.api.solver.SolverManager;

@Path("/timeTable")
public class TimeTableResource {

    @Inject
    SolverManager<TimeTable, UUID> solverManager;

    @POST
    @Path("/solve")
    public TimeTable solve(TimeTable problem) {
        UUID problemId = UUID.randomUUID();
        // Submit the problem to start solving
        SolverJob<TimeTable, UUID> solverJob = solverManager.solve(problemId, problem);
        TimeTable solution;
        try {
            // Wait until the solving ends
            solution = solverJob.getFinalBestSolution();
        } catch (InterruptedException | ExecutionException e) {
            throw new IllegalStateException("Solving failed.", e);
        }
        return solution;
    }

}

此初始实施会等待解决方法完成，这仍然可能导致 HTTP 超时。完整的实现可避免 HTTP 超时更明确。

如果您的计划应用程序没有终止设置或终止事件，它理论上会永久运行，并最终会导致 HTTP 超时错误。要防止这种情况发生，请使用 optaplanner.solver.termination.spent-limit 参数指定应用程序终止的时间长度。在大多数应用程序中，将时间至少设置为五分钟(5m)。但是，在 Timetable 示例中，将解决时间限制为 5 秒，这不足以避免 HTTP 超时。

quarkus.optaplanner.solver.termination.spent-limit=5s

创建了 school timetable 项目后，以开发模式运行它。在开发模式中，您可以在应用程序运行时更新应用程序源和配置。您的更改将显示在正在运行的应用程序中。

良好的应用程序包括测试覆盖。测试您时间项目中的限制和解决方法。

package org.acme.optaplanner.solver;

import java.time.DayOfWeek;
import java.time.LocalTime;

import javax.inject.Inject;

import io.quarkus.test.junit.QuarkusTest;
import org.acme.optaplanner.domain.Lesson;
import org.acme.optaplanner.domain.Room;
import org.acme.optaplanner.domain.TimeTable;
import org.acme.optaplanner.domain.Timeslot;
import org.junit.jupiter.api.Test;
import org.optaplanner.test.api.score.stream.ConstraintVerifier;

@QuarkusTest
class TimeTableConstraintProviderTest {

    private static final Room ROOM = new Room("Room1");
    private static final Timeslot TIMESLOT1 = new Timeslot(DayOfWeek.MONDAY, LocalTime.of(9,0), LocalTime.NOON);
    private static final Timeslot TIMESLOT2 = new Timeslot(DayOfWeek.TUESDAY, LocalTime.of(9,0), LocalTime.NOON);

    @Inject
    ConstraintVerifier<TimeTableConstraintProvider, TimeTable> constraintVerifier;

    @Test
    void roomConflict() {
        Lesson firstLesson = new Lesson(1, "Subject1", "Teacher1", "Group1");
        Lesson conflictingLesson = new Lesson(2, "Subject2", "Teacher2", "Group2");
        Lesson nonConflictingLesson = new Lesson(3, "Subject3", "Teacher3", "Group3");

        firstLesson.setRoom(ROOM);
        firstLesson.setTimeslot(TIMESLOT1);

        conflictingLesson.setRoom(ROOM);
        conflictingLesson.setTimeslot(TIMESLOT1);

        nonConflictingLesson.setRoom(ROOM);
        nonConflictingLesson.setTimeslot(TIMESLOT2);

        constraintVerifier.verifyThat(TimeTableConstraintProvider::roomConflict)
                .given(firstLesson, conflictingLesson, nonConflictingLesson)
                .penalizesBy(1);
    }

}

完成 OptaPlanner school 时间项目的红帽构建后，您可以使用日志信息帮助您微调 ConstraintProvider 中的限制。查看 info 日志文件中的分数计算速度，以评估对您的限制更改的影响。以 debug 模式运行应用程序，显示应用程序接受的每个步骤，或使用 trace 日志记录记录每一步和每次移动。

创建 Quarkus OptaPlanner school 时间应用程序后，您可以将其与数据库集成，并创建一个基于 Web 的用户界面来显示时间稳定。

OptaPlanner 通过 Micrometer 公开指标数据，这是 Java 应用程序的指标检测库。您可以将 Micrometer 与 Prometheus 搭配使用以监控 school timetable 应用程序中 OptaPlanner solver。

调度 appointments 的方法主要有两种。系统可以允许个人选择一个选项插槽（用户选择）或者系统分配一个插槽并告知个人何时和位置参加（系统自动自动分配分配）。OptaPlanner vaccination appointment 调度程序使用 system-automatically-assigns 方法。通过 OptaPlanner vaccination appointment 调度程序，您可以创建一个应用程序，其中人们为系统提供信息，系统会分配一个 appointment。

这个方法的特性：

这个方法可以通过使用计划限制为每个人创建分数来解决 vaccinating 的问题。个人的分数决定何时获得指示。个人得分越大，他们收到之前的发言的机会越大。

11.1.2. OptaPlanner solver

OptaPlanner 的核心是解决方法，引擎用于提取问题数据集并覆盖规划限制和配置。问题数据集包含人们、vaccines 和 vaccination 中心的所有信息。解决器通过各种数据组合进行工作，最终决定一个经过优化的指示计划，与分配给特定中心的 vaccination appointments 的人员进行优化。以下示例显示一个临时解决方案创建的调度：

11.1.3. 持续规划

持续计划是同时管理一个或多个即将举办的规划期的技术，并经常重复该过程每月、每周、每天、每小时或更频繁地重复该过程。计划窗口按指定间隔递增。下图显示了两周计划窗口，每天更新：

两周规划窗口被分为一半。第一周处于已发布的状态，第二周处于草案状态。人们被分配到计划窗口发布和部分的发言。但是，只有计划窗口发布的一部分的用户才会获得其发言通知。其他的 appointments 仍可在下一次运行时轻松更改。这样做可让 OptaPlanner 灵活地在再次运行问题时更改草案部分中的提示（如果需要）。例如，如果一个需要第二个操作的人准备了星期一，OptaPlanner 认为是星期三的准备日期，如果您可以证明 OptaPlanner，则可以为星期一给出一个草案。

您可以确定规划窗口的大小，但只了解问题空间的大小。问题空间就是创建计划的所有元素。您提前计划的时间越大，问题就越大。

下载 OptaPlanner vaccination appointment 调度程序快速启动存档，以 Quarkus 开发模式启动存档，并在浏览器中查看应用程序。Quarkus 开发模式允许您在运行过程中进行更改和更新应用程序。

当您完成了对 OptaPlanner vaccination appointment 调度程序的开发工作后，以 quarkus:dev 模式运行应用程序，作为传统的 jar 文件运行。

要利用 Quarkus 提供的小型内存占用和访问速度，在 Quarkus 原生模式下编译 OptaPlanner vaccination appointment 调度程序。

要查看红帽使用 Spring Boot 产品构建 OptaPlanner 的 school 时间项目的已完成示例，请从红帽客户门户网站下载入门应用程序。

红帽构建的 OptaPlanner 时间表项目的目标是将每节分配给一个时间段和一个房间。为此，请添加三个类： Timeslot、Lesson 和 Room，如下图所示：

时间段没有日期，因为高校的计划只每周重复。无法进行持续 规划。次性被称为 问题事实，因为在解决过程中不会有定时实例变化。此类类不需要任何特定于 OptaPlanner 的注解。

房间 实例在解决过程中不会改变，因此 Room 也是 问题。

在寻求过程中，OptaPlanner 改变了 lesson 类的 timelot 和 room 字段，从而将每个较小的时间分配给一个时间段和一个房间。 因为 OptaPlanner 更改了这些字段，所以 lesson 是一个 规划实体 ：

上图中的大多数字段包含输入数据，但 orange 字段除外。在输入数据中 未分配的 时间和房间 字段(null)，并在输出数据中分配（而不是 null）。OptaPlanner 在解决过程中更改这些字段。这些字段称为规划变量。为了 OptaPlanner 可以识别它们，timelot 和 room 字段都需要 @PlanningVariable 注解。它们包含类( Lesson )需要 @PlanningEntity 注释。

当解决问题时，分数 代表特定解决方案的质量。得分越高。红帽构建的 OptaPlanner 寻找最佳解决方案，这是可用时间获得最高分数的解决方案。这可能是 最佳解决方案。

因为可时间的示例用例具有硬和软约束，因此请使用 HardSoftScore 类来代表分数：

硬约束的加法是相对于其他硬约束的权重。软限制会高于其他软限制。硬限制始终大于软限制，无论其对应的权重如何。

要计算分数，您可以实施 EasyScoreCalculator 类：

public class TimeTableEasyScoreCalculator implements EasyScoreCalculator<TimeTable> {

    @Override
    public HardSoftScore calculateScore(TimeTable timeTable) {
        List<Lesson> lessonList = timeTable.getLessonList();
        int hardScore = 0;
        for (Lesson a : lessonList) {
            for (Lesson b : lessonList) {
                if (a.getTimeslot() != null && a.getTimeslot().equals(b.getTimeslot())
                        && a.getId() < b.getId()) {
                    // A room can accommodate at most one lesson at the same time.
                    if (a.getRoom() != null && a.getRoom().equals(b.getRoom())) {
                        hardScore--;
                    }
                    // A teacher can teach at most one lesson at the same time.
                    if (a.getTeacher().equals(b.getTeacher())) {
                        hardScore--;
                    }
                    // A student can attend at most one lesson at the same time.
                    if (a.getStudentGroup().equals(b.getStudentGroup())) {
                        hardScore--;
                    }
                }
            }
        }
        int softScore = 0;
        // Soft constraints are only implemented in the "complete" implementation
        return HardSoftScore.of(hardScore, softScore);
    }

}

不幸的是，这个解决方案无法进行很好的扩展，因为它是非增量：每次分配给不同的时间段或房间，都会重新评估所有课程来计算新分数。

更好的解决方法是创建一个 src/main/java/com/example/solver/TimeTableConstraintProvider.java 类来执行增量分数计算。此类使用 OptaPlanner 的 ConstraintStream API，它由 Java 8 Streams 和 SQL 产生。ConstraintProvider 缩放比 EasyScoreCalculator 更好的度量：O(n)而不是 O(n)。

package com.example.solver;

import com.example.domain.Lesson;
import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
import org.optaplanner.core.api.score.stream.Constraint;
import org.optaplanner.core.api.score.stream.ConstraintFactory;
import org.optaplanner.core.api.score.stream.ConstraintProvider;
import org.optaplanner.core.api.score.stream.Joiners;

public class TimeTableConstraintProvider implements ConstraintProvider {

    @Override
    public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
        return new Constraint[] {
                // Hard constraints
                roomConflict(constraintFactory),
                teacherConflict(constraintFactory),
                studentGroupConflict(constraintFactory),
                // Soft constraints are only implemented in the "complete" implementation
        };
    }

    private Constraint roomConflict(ConstraintFactory constraintFactory) {
        // A room can accommodate at most one lesson at the same time.

        // Select a lesson ...
        return constraintFactory.from(Lesson.class)
                // ... and pair it with another lesson ...
                .join(Lesson.class,
                        // ... in the same timeslot ...
                        Joiners.equal(Lesson::getTimeslot),
                        // ... in the same room ...
                        Joiners.equal(Lesson::getRoom),
                        // ... and the pair is unique (different id, no reverse pairs)
                        Joiners.lessThan(Lesson::getId))
                // then penalize each pair with a hard weight.
                .penalize("Room conflict", HardSoftScore.ONE_HARD);
    }

    private Constraint teacherConflict(ConstraintFactory constraintFactory) {
        // A teacher can teach at most one lesson at the same time.
        return constraintFactory.from(Lesson.class)
                .join(Lesson.class,
                        Joiners.equal(Lesson::getTimeslot),
                        Joiners.equal(Lesson::getTeacher),
                        Joiners.lessThan(Lesson::getId))
                .penalize("Teacher conflict", HardSoftScore.ONE_HARD);
    }

    private Constraint studentGroupConflict(ConstraintFactory constraintFactory) {
        // A student can attend at most one lesson at the same time.
        return constraintFactory.from(Lesson.class)
                .join(Lesson.class,
                        Joiners.equal(Lesson::getTimeslot),
                        Joiners.equal(Lesson::getStudentGroup),
                        Joiners.lessThan(Lesson::getId))
                .penalize("Student group conflict", HardSoftScore.ONE_HARD);
    }

}

TimeTable 实例嵌套了单个 dataset 的所有 Timeslot、Room 和 Lesson 实例。另外，由于它包含了 allon，每个都具有特定规划变量状态，所以它是一个 规划解决方案，并有分数：

TimeTable 类有一个 @PlanningSolution 注释，因此红帽构建的 OptaPlanner 知道该类包含所有输入和输出数据。

具体来说，这个类是问题的输入：

但是，这个类也是解决方案的输出：

package com.example.domain;

import java.util.List;

import org.optaplanner.core.api.domain.solution.PlanningEntityCollectionProperty;
import org.optaplanner.core.api.domain.solution.PlanningScore;
import org.optaplanner.core.api.domain.solution.PlanningSolution;
import org.optaplanner.core.api.domain.solution.ProblemFactCollectionProperty;
import org.optaplanner.core.api.domain.valuerange.ValueRangeProvider;
import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;

@PlanningSolution
public class TimeTable {

    @ValueRangeProvider(id = "timeslotRange")
    @ProblemFactCollectionProperty
    private List<Timeslot> timeslotList;

    @ValueRangeProvider(id = "roomRange")
    @ProblemFactCollectionProperty
    private List<Room> roomList;

    @PlanningEntityCollectionProperty
    private List<Lesson> lessonList;

    @PlanningScore
    private HardSoftScore score;

    private TimeTable() {
    }

    public TimeTable(List<Timeslot> timeslotList, List<Room> roomList,
            List<Lesson> lessonList) {
        this.timeslotList = timeslotList;
        this.roomList = roomList;
        this.lessonList = lessonList;
    }

    // ********************************
    // Getters and setters
    // ********************************

    public List<Timeslot> getTimeslotList() {
        return timeslotList;
    }

    public List<Room> getRoomList() {
        return roomList;
    }

    public List<Lesson> getLessonList() {
        return lessonList;
    }

    public HardSoftScore getScore() {
        return score;
    }

}

遵循相同的逻辑，roomList 字段也有 @ValueRangeProvider 注释。

time lotList 和 roomList 字段具有 @ProblemFactCollectionProperty 注释，因此您的 TimeTableConstraintProvider 可以从这些实例中进行选择。

lessonList 有一个 @PlanningEntityCollectionProperty 注解，因此 OptaPlanner 可在解决过程中更改它们，并且您的 TimeTableConstraintProvider 也可从那些中选择。

现在，您已准备好将所有内容放在一起并创建 REST 服务。但解决 REST 线程中的规划问题会导致 HTTP 超时问题。因此，Spring Boot 启动程序注入 SolverManager，它将在一个单独的线程池中运行 solvers，并可以并行解决多个数据集。

package com.example.solver;

import java.util.UUID;
import java.util.concurrent.ExecutionException;

import com.example.domain.TimeTable;
import org.optaplanner.core.api.solver.SolverJob;
import org.optaplanner.core.api.solver.SolverManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/timeTable")
public class TimeTableController {

    @Autowired
    private SolverManager<TimeTable, UUID> solverManager;

    @PostMapping("/solve")
    public TimeTable solve(@RequestBody TimeTable problem) {
        UUID problemId = UUID.randomUUID();
        // Submit the problem to start solving
        SolverJob<TimeTable, UUID> solverJob = solverManager.solve(problemId, problem);
        TimeTable solution;
        try {
            // Wait until the solving ends
            solution = solverJob.getFinalBestSolution();
        } catch (InterruptedException | ExecutionException e) {
            throw new IllegalStateException("Solving failed.", e);
        }
        return solution;
    }

}

在本例中，初始实现会等待解决方法完成，这仍然可能导致 HTTP 超时。完整的 实现可避免 HTTP 超时更明确。

如果您的计划应用程序没有终止设置或终止事件，它理论上会永久运行，并最终会导致 HTTP 超时错误。要防止这种情况发生，请使用 optaplanner.solver.termination.spent-limit 参数指定应用程序终止的时间长度。在大多数应用程序中，将时间至少设置为五分钟(5m)。但是，在 Timetable 示例中，将解决时间限制为 5 秒，这不足以避免 HTTP 超时。

quarkus.optaplanner.solver.termination.spent-limit=5s

完成 OptaPlanner Spring Boot timetable 项目的红帽构建后，将所有内容打包成由标准 Java main（） 方法驱动的单个可执行 JAR 文件。

$ curl -i -X POST http://localhost:8080/timeTable/solve -H "Content-Type:application/json" -d '{"timeslotList":[{"dayOfWeek":"MONDAY","startTime":"08:30:00","endTime":"09:30:00"},{"dayOfWeek":"MONDAY","startTime":"09:30:00","endTime":"10:30:00"}],"roomList":[{"name":"Room A"},{"name":"Room B"}],"lessonList":[{"id":1,"subject":"Math","teacher":"A. Turing","studentGroup":"9th grade"},{"id":2,"subject":"Chemistry","teacher":"M. Curie","studentGroup":"9th grade"},{"id":3,"subject":"French","teacher":"M. Curie","studentGroup":"10th grade"},{"id":4,"subject":"History","teacher":"I. Jones","studentGroup":"10th grade"}]}'

HTTP/1.1 200
Content-Type: application/json
...

{"timeslotList":...,"roomList":...,"lessonList":[{"id":1,"subject":"Math","teacher":"A. Turing","studentGroup":"9th grade","timeslot":{"dayOfWeek":"MONDAY","startTime":"08:30:00","endTime":"09:30:00"},"room":{"name":"Room A"}},{"id":2,"subject":"Chemistry","teacher":"M. Curie","studentGroup":"9th grade","timeslot":{"dayOfWeek":"MONDAY","startTime":"09:30:00","endTime":"10:30:00"},"room":{"name":"Room A"}},{"id":3,"subject":"French","teacher":"M. Curie","studentGroup":"10th grade","timeslot":{"dayOfWeek":"MONDAY","startTime":"08:30:00","endTime":"09:30:00"},"room":{"name":"Room B"}},{"id":4,"subject":"History","teacher":"I. Jones","studentGroup":"10th grade","timeslot":{"dayOfWeek":"MONDAY","startTime":"09:30:00","endTime":"10:30:00"},"room":{"name":"Room B"}}],"score":"0hard/0soft"}

... Solving started: time spent (33), best score (-8init/0hard/0soft), environment mode (REPRODUCIBLE), random (JDK with seed 0).
... Construction Heuristic phase (0) ended: time spent (73), best score (0hard/0soft), score calculation speed (459/sec), step total (4).
... Local Search phase (1) ended: time spent (5000), best score (0hard/0soft), score calculation speed (28949/sec), step total (28398).
... Solving ended: time spent (5000), best score (0hard/0soft), score calculation speed (28524/sec), phase total (2), environment mode (REPRODUCIBLE).

package com.example.solver;

import java.time.DayOfWeek;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

import com.example.domain.Lesson;
import com.example.domain.Room;
import com.example.domain.TimeTable;
import com.example.domain.Timeslot;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

@SpringBootTest(properties = {
        "optaplanner.solver.termination.spent-limit=1h", // Effectively disable this termination in favor of the best-score-limit
        "optaplanner.solver.termination.best-score-limit=0hard/*soft"})
public class TimeTableControllerTest {

    @Autowired
    private TimeTableController timeTableController;

    @Test
    @Timeout(600_000)
    public void solve() {
        TimeTable problem = generateProblem();
        TimeTable solution = timeTableController.solve(problem);
        assertFalse(solution.getLessonList().isEmpty());
        for (Lesson lesson : solution.getLessonList()) {
            assertNotNull(lesson.getTimeslot());
            assertNotNull(lesson.getRoom());
        }
        assertTrue(solution.getScore().isFeasible());
    }

    private TimeTable generateProblem() {
        List<Timeslot> timeslotList = new ArrayList<>();
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(8, 30), LocalTime.of(9, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(9, 30), LocalTime.of(10, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(10, 30), LocalTime.of(11, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(13, 30), LocalTime.of(14, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(14, 30), LocalTime.of(15, 30)));

        List<Room> roomList = new ArrayList<>();
        roomList.add(new Room("Room A"));
        roomList.add(new Room("Room B"));
        roomList.add(new Room("Room C"));

        List<Lesson> lessonList = new ArrayList<>();
        lessonList.add(new Lesson(101L, "Math", "B. May", "9th grade"));
        lessonList.add(new Lesson(102L, "Physics", "M. Curie", "9th grade"));
        lessonList.add(new Lesson(103L, "Geography", "M. Polo", "9th grade"));
        lessonList.add(new Lesson(104L, "English", "I. Jones", "9th grade"));
        lessonList.add(new Lesson(105L, "Spanish", "P. Cruz", "9th grade"));

        lessonList.add(new Lesson(201L, "Math", "B. May", "10th grade"));
        lessonList.add(new Lesson(202L, "Chemistry", "M. Curie", "10th grade"));
        lessonList.add(new Lesson(203L, "History", "I. Jones", "10th grade"));
        lessonList.add(new Lesson(204L, "English", "P. Cruz", "10th grade"));
        lessonList.add(new Lesson(205L, "French", "M. Curie", "10th grade"));
        return new TimeTable(timeslotList, roomList, lessonList);
    }

}

在使用 Spring Boot 创建红帽构建的 OptaPlanner 应用程序示例后，添加数据库和 UI 集成。

OptaPlanner 通过 Micrometer 公开指标数据，这是 Java 应用程序的指标检测库。您可以将 Micrometer 与 Prometheus 搭配使用以监控 school timetable 应用程序中 OptaPlanner solver。

您可以将 Maven 或 Gradle 用于 OptaPlanner unitable 应用程序。创建构建文件后，添加以下依赖项：

红帽构建的 OptaPlanner 时间表项目的目标是将每节分配给一个时间段和一个房间。为此，请添加三个类： Timeslot、Lesson 和 Room，如下图所示：

时间段没有日期，因为高校的计划只每周重复。无法进行持续 规划。次性被称为 问题事实，因为在解决过程中不会有定时实例变化。此类类不需要任何特定于 OptaPlanner 的注解。

房间 实例在解决过程中不会改变，因此 Room 也是 问题。

在寻求过程中，OptaPlanner 改变了 lesson 类的 timelot 和 room 字段，从而将每个较小的时间分配给一个时间段和一个房间。 因为 OptaPlanner 更改了这些字段，所以 lesson 是一个 规划实体 ：

上图中的大多数字段包含输入数据，但 orange 字段除外。在输入数据中 未分配的 时间和房间 字段(null)，并在输出数据中分配（而不是 null）。OptaPlanner 在解决过程中更改这些字段。这些字段称为规划变量。为了 OptaPlanner 可以识别它们，timelot 和 room 字段都需要 @PlanningVariable 注解。它们包含类( Lesson )需要 @PlanningEntity 注释。

当解决问题时，分数 代表特定解决方案的质量。得分越高。红帽构建的 OptaPlanner 寻找最佳解决方案，这是可用时间获得最高分数的解决方案。这可能是 最佳解决方案。

因为可时间的示例用例具有硬和软约束，因此请使用 HardSoftScore 类来代表分数：

硬约束的加法是相对于其他硬约束的权重。软限制会高于其他软限制。硬限制始终大于软限制，无论其对应的权重如何。

要计算分数，您可以实施 EasyScoreCalculator 类：

public class TimeTableEasyScoreCalculator implements EasyScoreCalculator<TimeTable> {

    @Override
    public HardSoftScore calculateScore(TimeTable timeTable) {
        List<Lesson> lessonList = timeTable.getLessonList();
        int hardScore = 0;
        for (Lesson a : lessonList) {
            for (Lesson b : lessonList) {
                if (a.getTimeslot() != null && a.getTimeslot().equals(b.getTimeslot())
                        && a.getId() < b.getId()) {
                    // A room can accommodate at most one lesson at the same time.
                    if (a.getRoom() != null && a.getRoom().equals(b.getRoom())) {
                        hardScore--;
                    }
                    // A teacher can teach at most one lesson at the same time.
                    if (a.getTeacher().equals(b.getTeacher())) {
                        hardScore--;
                    }
                    // A student can attend at most one lesson at the same time.
                    if (a.getStudentGroup().equals(b.getStudentGroup())) {
                        hardScore--;
                    }
                }
            }
        }
        int softScore = 0;
        // Soft constraints are only implemented in the "complete" implementation
        return HardSoftScore.of(hardScore, softScore);
    }

}

不幸的是，这个解决方案无法进行很好的扩展，因为它是非增量：每次分配给不同的时间段或房间，都会重新评估所有课程来计算新分数。

更好的解决方法是创建一个 src/main/java/com/example/solver/TimeTableConstraintProvider.java 类来执行增量分数计算。此类使用 OptaPlanner 的 ConstraintStream API，它由 Java 8 Streams 和 SQL 产生。ConstraintProvider 缩放比 EasyScoreCalculator 更好的度量：O(n)而不是 O(n)。

package com.example.solver;

import com.example.domain.Lesson;
import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
import org.optaplanner.core.api.score.stream.Constraint;
import org.optaplanner.core.api.score.stream.ConstraintFactory;
import org.optaplanner.core.api.score.stream.ConstraintProvider;
import org.optaplanner.core.api.score.stream.Joiners;

public class TimeTableConstraintProvider implements ConstraintProvider {

    @Override
    public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
        return new Constraint[] {
                // Hard constraints
                roomConflict(constraintFactory),
                teacherConflict(constraintFactory),
                studentGroupConflict(constraintFactory),
                // Soft constraints are only implemented in the "complete" implementation
        };
    }

    private Constraint roomConflict(ConstraintFactory constraintFactory) {
        // A room can accommodate at most one lesson at the same time.

        // Select a lesson ...
        return constraintFactory.from(Lesson.class)
                // ... and pair it with another lesson ...
                .join(Lesson.class,
                        // ... in the same timeslot ...
                        Joiners.equal(Lesson::getTimeslot),
                        // ... in the same room ...
                        Joiners.equal(Lesson::getRoom),
                        // ... and the pair is unique (different id, no reverse pairs)
                        Joiners.lessThan(Lesson::getId))
                // then penalize each pair with a hard weight.
                .penalize("Room conflict", HardSoftScore.ONE_HARD);
    }

    private Constraint teacherConflict(ConstraintFactory constraintFactory) {
        // A teacher can teach at most one lesson at the same time.
        return constraintFactory.from(Lesson.class)
                .join(Lesson.class,
                        Joiners.equal(Lesson::getTimeslot),
                        Joiners.equal(Lesson::getTeacher),
                        Joiners.lessThan(Lesson::getId))
                .penalize("Teacher conflict", HardSoftScore.ONE_HARD);
    }

    private Constraint studentGroupConflict(ConstraintFactory constraintFactory) {
        // A student can attend at most one lesson at the same time.
        return constraintFactory.from(Lesson.class)
                .join(Lesson.class,
                        Joiners.equal(Lesson::getTimeslot),
                        Joiners.equal(Lesson::getStudentGroup),
                        Joiners.lessThan(Lesson::getId))
                .penalize("Student group conflict", HardSoftScore.ONE_HARD);
    }

}

TimeTable 实例嵌套了单个 dataset 的所有 Timeslot、Room 和 Lesson 实例。另外，由于它包含了 allon，每个都具有特定规划变量状态，所以它是一个 规划解决方案，并有分数：

TimeTable 类有一个 @PlanningSolution 注释，因此红帽构建的 OptaPlanner 知道该类包含所有输入和输出数据。

具体来说，这个类是问题的输入：

但是，这个类也是解决方案的输出：

package com.example.domain;

import java.util.List;

import org.optaplanner.core.api.domain.solution.PlanningEntityCollectionProperty;
import org.optaplanner.core.api.domain.solution.PlanningScore;
import org.optaplanner.core.api.domain.solution.PlanningSolution;
import org.optaplanner.core.api.domain.solution.ProblemFactCollectionProperty;
import org.optaplanner.core.api.domain.valuerange.ValueRangeProvider;
import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;

@PlanningSolution
public class TimeTable {

    @ValueRangeProvider(id = "timeslotRange")
    @ProblemFactCollectionProperty
    private List<Timeslot> timeslotList;

    @ValueRangeProvider(id = "roomRange")
    @ProblemFactCollectionProperty
    private List<Room> roomList;

    @PlanningEntityCollectionProperty
    private List<Lesson> lessonList;

    @PlanningScore
    private HardSoftScore score;

    private TimeTable() {
    }

    public TimeTable(List<Timeslot> timeslotList, List<Room> roomList,
            List<Lesson> lessonList) {
        this.timeslotList = timeslotList;
        this.roomList = roomList;
        this.lessonList = lessonList;
    }

    // ********************************
    // Getters and setters
    // ********************************

    public List<Timeslot> getTimeslotList() {
        return timeslotList;
    }

    public List<Room> getRoomList() {
        return roomList;
    }

    public List<Lesson> getLessonList() {
        return lessonList;
    }

    public HardSoftScore getScore() {
        return score;
    }

}

遵循相同的逻辑，roomList 字段也有 @ValueRangeProvider 注释。

time lotList 和 roomList 字段具有 @ProblemFactCollectionProperty 注释，因此您的 TimeTableConstraintProvider 可以从这些实例中进行选择。

lessonList 有一个 @PlanningEntityCollectionProperty 注解，因此 OptaPlanner 可在解决过程中更改它们，并且您的 TimeTableConstraintProvider 也可从那些中选择。

在创建了 school timetable 应用的所有组件后，您将把它们放到 TimeTableApp.java 类中。

main（） 方法执行以下任务：

通常，一个应用程序有一个 SolverFactory，用于为每个问题数据设置一个新的 Solver 实例，用于解决每个问题数据。SolverFactory 是线程安全，但 Solver 不是。对于 school timetable 应用，只有一个数据集，因此只有一个 Solver 实例。

以下是完成的 TimeTableApp.java 类：

package org.acme.schooltimetabling;

import java.time.DayOfWeek;
import java.time.Duration;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.acme.schooltimetabling.domain.Lesson;
import org.acme.schooltimetabling.domain.Room;
import org.acme.schooltimetabling.domain.TimeTable;
import org.acme.schooltimetabling.domain.Timeslot;
import org.acme.schooltimetabling.solver.TimeTableConstraintProvider;
import org.optaplanner.core.api.solver.Solver;
import org.optaplanner.core.api.solver.SolverFactory;
import org.optaplanner.core.config.solver.SolverConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TimeTableApp {

    private static final Logger LOGGER = LoggerFactory.getLogger(TimeTableApp.class);

    public static void main(String[] args) {
        SolverFactory<TimeTable> solverFactory = SolverFactory.create(new SolverConfig()
                .withSolutionClass(TimeTable.class)
                .withEntityClasses(Lesson.class)
                .withConstraintProviderClass(TimeTableConstraintProvider.class)
                // The solver runs only for 5 seconds on this small data set.
                // It's recommended to run for at least 5 minutes ("5m") otherwise.
                .withTerminationSpentLimit(Duration.ofSeconds(10)));

        // Load the problem
        TimeTable problem = generateDemoData();

        // Solve the problem
        Solver<TimeTable> solver = solverFactory.buildSolver();
        TimeTable solution = solver.solve(problem);

        // Visualize the solution
        printTimetable(solution);
    }

    public static TimeTable generateDemoData() {
        List<Timeslot> timeslotList = new ArrayList<>(10);
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(8, 30), LocalTime.of(9, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(9, 30), LocalTime.of(10, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(10, 30), LocalTime.of(11, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(13, 30), LocalTime.of(14, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.MONDAY, LocalTime.of(14, 30), LocalTime.of(15, 30)));

        timeslotList.add(new Timeslot(DayOfWeek.TUESDAY, LocalTime.of(8, 30), LocalTime.of(9, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.TUESDAY, LocalTime.of(9, 30), LocalTime.of(10, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.TUESDAY, LocalTime.of(10, 30), LocalTime.of(11, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.TUESDAY, LocalTime.of(13, 30), LocalTime.of(14, 30)));
        timeslotList.add(new Timeslot(DayOfWeek.TUESDAY, LocalTime.of(14, 30), LocalTime.of(15, 30)));

        List<Room> roomList = new ArrayList<>(3);
        roomList.add(new Room("Room A"));
        roomList.add(new Room("Room B"));
        roomList.add(new Room("Room C"));

        List<Lesson> lessonList = new ArrayList<>();
        long id = 0;
        lessonList.add(new Lesson(id++, "Math", "A. Turing", "9th grade"));
        lessonList.add(new Lesson(id++, "Math", "A. Turing", "9th grade"));
        lessonList.add(new Lesson(id++, "Physics", "M. Curie", "9th grade"));
        lessonList.add(new Lesson(id++, "Chemistry", "M. Curie", "9th grade"));
        lessonList.add(new Lesson(id++, "Biology", "C. Darwin", "9th grade"));
        lessonList.add(new Lesson(id++, "History", "I. Jones", "9th grade"));
        lessonList.add(new Lesson(id++, "English", "I. Jones", "9th grade"));
        lessonList.add(new Lesson(id++, "English", "I. Jones", "9th grade"));
        lessonList.add(new Lesson(id++, "Spanish", "P. Cruz", "9th grade"));
        lessonList.add(new Lesson(id++, "Spanish", "P. Cruz", "9th grade"));

        lessonList.add(new Lesson(id++, "Math", "A. Turing", "10th grade"));
        lessonList.add(new Lesson(id++, "Math", "A. Turing", "10th grade"));
        lessonList.add(new Lesson(id++, "Math", "A. Turing", "10th grade"));
        lessonList.add(new Lesson(id++, "Physics", "M. Curie", "10th grade"));
        lessonList.add(new Lesson(id++, "Chemistry", "M. Curie", "10th grade"));
        lessonList.add(new Lesson(id++, "French", "M. Curie", "10th grade"));
        lessonList.add(new Lesson(id++, "Geography", "C. Darwin", "10th grade"));
        lessonList.add(new Lesson(id++, "History", "I. Jones", "10th grade"));
        lessonList.add(new Lesson(id++, "English", "P. Cruz", "10th grade"));
        lessonList.add(new Lesson(id++, "Spanish", "P. Cruz", "10th grade"));

        return new TimeTable(timeslotList, roomList, lessonList);
    }

    private static void printTimetable(TimeTable timeTable) {
        LOGGER.info("");
        List<Room> roomList = timeTable.getRoomList();
        List<Lesson> lessonList = timeTable.getLessonList();
        Map<Timeslot, Map<Room, List<Lesson>>> lessonMap = lessonList.stream()
                .filter(lesson -> lesson.getTimeslot() != null && lesson.getRoom() != null)
                .collect(Collectors.groupingBy(Lesson::getTimeslot, Collectors.groupingBy(Lesson::getRoom)));
        LOGGER.info("|            | " + roomList.stream()
                .map(room -> String.format("%-10s", room.getName())).collect(Collectors.joining(" | ")) + " |");
        LOGGER.info("|" + "------------|".repeat(roomList.size() + 1));
        for (Timeslot timeslot : timeTable.getTimeslotList()) {
            List<List<Lesson>> cellList = roomList.stream()
                    .map(room -> {
                        Map<Room, List<Lesson>> byRoomMap = lessonMap.get(timeslot);
                        if (byRoomMap == null) {
                            return Collections.<Lesson>emptyList();
                        }
                        List<Lesson> cellLessonList = byRoomMap.get(room);
                        if (cellLessonList == null) {
                            return Collections.<Lesson>emptyList();
                        }
                        return cellLessonList;
                    })
                    .collect(Collectors.toList());

            LOGGER.info("| " + String.format("%-10s",
                    timeslot.getDayOfWeek().toString().substring(0, 3) + " " + timeslot.getStartTime()) + " | "
                    + cellList.stream().map(cellLessonList -> String.format("%-10s",
                            cellLessonList.stream().map(Lesson::getSubject).collect(Collectors.joining(", "))))
                            .collect(Collectors.joining(" | "))
                    + " |");
            LOGGER.info("|            | "
                    + cellList.stream().map(cellLessonList -> String.format("%-10s",
                            cellLessonList.stream().map(Lesson::getTeacher).collect(Collectors.joining(", "))))
                            .collect(Collectors.joining(" | "))
                    + " |");
            LOGGER.info("|            | "
                    + cellList.stream().map(cellLessonList -> String.format("%-10s",
                            cellLessonList.stream().map(Lesson::getStudentGroup).collect(Collectors.joining(", "))))
                            .collect(Collectors.joining(" | "))
                    + " |");
            LOGGER.info("|" + "------------|".repeat(roomList.size() + 1));
        }
        List<Lesson> unassignedLessons = lessonList.stream()
                .filter(lesson -> lesson.getTimeslot() == null || lesson.getRoom() == null)
                .collect(Collectors.toList());
        if (!unassignedLessons.isEmpty()) {
            LOGGER.info("");
            LOGGER.info("Unassigned lessons");
            for (Lesson lesson : unassignedLessons) {
                LOGGER.info("  " + lesson.getSubject() + " - " + lesson.getTeacher() + " - " + lesson.getStudentGroup());
            }
        }
    }

}

main（） 方法首先创建 SolverFactory ：

SolverFactory<TimeTable> solverFactory = SolverFactory.create(new SolverConfig()
        .withSolutionClass(TimeTable.class)
        .withEntityClasses(Lesson.class)
        .withConstraintProviderClass(TimeTableConstraintProvider.class)
        // The solver runs only for 5 seconds on this small data set.
        // It's recommended to run for at least 5 minutes ("5m") otherwise.
        .withTerminationSpentLimit(Duration.ofSeconds(5)));

SolverFactory 创建注册 @PlanningSolution 类、@PlanningEntity 类和 ConstraintProvider 类（您之前创建的所有组件）。

如果没有终止设置或 terminationEarly（） 事件，解决者会永久运行。为避免这种情况，解决问题将解决时间限制为 5 秒。

5 秒后，main（） 方法加载问题，可解决这个问题并打印解决方案：

        // Load the problem
        TimeTable problem = generateDemoData();

        // Solve the problem
        Solver<TimeTable> solver = solverFactory.buildSolver();
        TimeTable solution = solver.solve(problem);

        // Visualize the solution
        printTimetable(solution);

solve（） 方法不会立即返回。在返回最佳解决方案前，它会持续 5 秒。

OptaPlanner 返回可用终止时间里 的最佳解决方案。由于 NP 划分问题的性质，最佳解决方案可能不是最佳的解决方案，特别是对于更大的数据集。增加终止时间，以有可能获得更好的解决方案。

generateDemoData（） 方法会生成 school timetable 问题来解决。

printTimetable（） 方法给控制台而生动，因此易于视觉确定是否适合自己的时间表。

您已完成了 school timetable Java 应用程序的所有组件，您已准备好将它们放在 TimeTableApp.java 类中并运行它。

info 日志显示 OptaPlanner 在 5 秒里执行的操作：

... Solving started: time spent (33), best score (-8init/0hard/0soft), environment mode (REPRODUCIBLE), random (JDK with seed 0).
... Construction Heuristic phase (0) ended: time spent (73), best score (0hard/0soft), score calculation speed (459/sec), step total (4).
... Local Search phase (1) ended: time spent (5000), best score (0hard/0soft), score calculation speed (28949/sec), step total (28398).
... Solving ended: time spent (5000), best score (0hard/0soft), score calculation speed (28524/sec), phase total (2), environment mode (REPRODUCIBLE).

良好的应用程序包括测试覆盖。测试您时间项目中的限制和解决方法。

package org.acme.optaplanner.solver;

import java.time.DayOfWeek;
import java.time.LocalTime;

import javax.inject.Inject;

import io.quarkus.test.junit.QuarkusTest;
import org.acme.optaplanner.domain.Lesson;
import org.acme.optaplanner.domain.Room;
import org.acme.optaplanner.domain.TimeTable;
import org.acme.optaplanner.domain.Timeslot;
import org.junit.jupiter.api.Test;
import org.optaplanner.test.api.score.stream.ConstraintVerifier;

@QuarkusTest
class TimeTableConstraintProviderTest {

    private static final Room ROOM = new Room("Room1");
    private static final Timeslot TIMESLOT1 = new Timeslot(DayOfWeek.MONDAY, LocalTime.of(9,0), LocalTime.NOON);
    private static final Timeslot TIMESLOT2 = new Timeslot(DayOfWeek.TUESDAY, LocalTime.of(9,0), LocalTime.NOON);

    @Inject
    ConstraintVerifier<TimeTableConstraintProvider, TimeTable> constraintVerifier;

    @Test
    void roomConflict() {
        Lesson firstLesson = new Lesson(1, "Subject1", "Teacher1", "Group1");
        Lesson conflictingLesson = new Lesson(2, "Subject2", "Teacher2", "Group2");
        Lesson nonConflictingLesson = new Lesson(3, "Subject3", "Teacher3", "Group3");

        firstLesson.setRoom(ROOM);
        firstLesson.setTimeslot(TIMESLOT1);

        conflictingLesson.setRoom(ROOM);
        conflictingLesson.setTimeslot(TIMESLOT1);

        nonConflictingLesson.setRoom(ROOM);
        nonConflictingLesson.setTimeslot(TIMESLOT2);

        constraintVerifier.verifyThat(TimeTableConstraintProvider::roomConflict)
                .given(firstLesson, conflictingLesson, nonConflictingLesson)
                .penalizesBy(1);
    }

}

完成 OptaPlanner school 时间项目的红帽构建后，您可以使用日志信息帮助您微调 ConstraintProvider 中的限制。查看 info 日志文件中的分数计算速度，以评估对您的限制更改的影响。以 debug 模式运行应用程序，显示应用程序接受的每个步骤，或使用 trace 日志记录记录每一步和每次移动。

OptaPlanner 通过 Micrometer 公开指标数据，这是 Java 应用程序的指标检测库。您可以将 Micrometer 与 Prometheus 搭配使用以监控 school timetable 应用程序中 OptaPlanner solver。

员工名单的入门应用程序为员工分配组织内各种位置的员工。例如，您可以使用应用程序在 nurses、guard duty 跨多个位置转移，或在 worker 之间的装配行转移。

最佳员工名单必须考虑很多变量。例如，不同的位置上会需要不同的技能来改变。另外，某些员工对于某些时间段不可用，或者可能首选特定时间段。此外，员工也可以有合同，该合同限制员工可在单个时间段内工作的小时数。

对于这个启动程序应用程序，红帽构建的 OptaPlanner 规则都使用 hard 和 soft 约束。在优化过程中，计划引擎可能不会违反硬约束，例如，如果员工不可用（开单位置），或者某个员工无法在单一转移中的两个位置工作。计划引擎会尝试遵守软限制，例如员工首选项不做特定的转变，但如果最佳解决方案需要，则可能会违反它们。

您可以从源代码构建员工级名入门应用程序，并将其作为 JAR 文件运行。

另外，您可以使用 IDE，如 Eclipse（包括 Red Hat CodeReady Studio）来构建和运行应用程序。

员工的入门应用程序由以下主要组件组成：

您可以独立构建和使用这些组件。特别是，您可以实施不同的用户界面，并使用 REST API 调用服务器。

除两个主要组件外，员工的 rostering 模板还包含随机源数据生成器（用于演示和测试目的）和基准测试应用程序。

模块包含多个文件，包括 Java 类。本文档列出了所有模块，以及包含员工计算计算关键信息的类和其他文件。

要修改 employees rostering starter 应用以满足您的需要，您必须更改管理优化过程的规则。您还必须确保数据结构包含所需的数据，并提供规则所需的计算结果。如果用户界面中不存在所需数据，还必须修改用户界面。

以下过程概述了修改员工的入门应用的一般方法。

员工名单的入门应用程序为员工分配组织内各种位置的员工。例如，您可以使用应用程序在 nurses、guard duty 跨多个位置转移，或在 worker 之间的装配行转移。

最佳员工名单必须考虑很多变量。例如，不同的位置上会需要不同的技能来改变。另外，某些员工对于某些时间段不可用，或者可能首选特定时间段。此外，员工也可以有合同，该合同限制员工可在单个时间段内工作的小时数。

对于这个启动程序应用程序，红帽构建的 OptaPlanner 规则都使用 hard 和 soft 约束。在优化过程中，计划引擎可能不会违反硬约束，例如，如果员工不可用（开单位置），或者某个员工无法在单一转移中的两个位置工作。计划引擎会尝试遵守软限制，例如员工首选项不做特定的转变，但如果最佳解决方案需要，则可能会违反它们。

使用 runOnOpenShift.sh 脚本将 Employee Rostering 入门程序应用程序部署到 Red Hat OpenShift Container Platform。runOnOpenShift.sh shell 脚本在 Red Hat Process Automation Manager 7.13.4 Kogito 和 OptaPlanner 8 Decision Services Quickstarts 发行版本中提供。

runOnOpenShift.sh 脚本在本地构建并打包应用程序源代码，并将它上传到 OpenShift 环境以进行部署。这个方法需要 Java Development Kit、Apache Maven 和 bash shell 命令行。

您可以使用 Web 界面使用 Employee Rostering 入门应用程序。接口在 ReactJS 中开发。您还可以根据需要访问 REST API 来创建自定义用户界面。

15.3.13. 查看并编辑轮转模式

通过轮转模式，您可以添加、移动和删除转变，以便您有效地管理员工资源。它通过时间存储桶和座位进行定义。

• 时间存储桶描述了一个时间插槽（例如，9:00 a.m. 至 5:00 p.m.）用于特定位置或位置 （例如，A） （例如：naestics）超过两天，以及需要（例如，开票培训）所需的任何技能。
• 座位 (B) 是特定日期在特定时间 bucket 中的员工分配。
• 员工存根是一个图标，表示可用于分配给时间 bucket 的员工。员工存根列在 Employee Stub 列表中。

有关轮转模式的更多信息，请参阅 第 15.3.2 节 “轮转模式”。

流程

1. 点 Rotation 选项卡查看并编辑轮转模式。
2. 从 Rotation 菜单中选择 spot。
3. 点 Add New Time Bucket。此时会显示 Creating Working Time Bucket 对话框。
4. 指定开始和结束时间，选择任何额外的所需技能，选择本时间存储桶的天数，然后单击 Save。此时间 bucket 的未分配位置显示在 Rotation 页面中，按时间范围组织。
5. 要创建员工 stub 列表，以便您可以向轮转添加员工，单击 编辑 Employee Stub 列表。
6. 在 Edit Employee Stub List 对话框中，单击 Add Employee，并从列表中选择一个员工。
7. 添加此 stub 列表需要的所有员工，然后单击保存。员工在 Rotation 页面上显示时间存储桶之上。
8. 单击员工图标，从员工 stub 列表中选择员工。

9. 单击鼠标并拖动鼠标，将所选员工分配到座位。座位将用员工图标填充。

   注意

   一个时间存储桶只能为每天分配一个员工。要向同一时间存储桶添加多个员工，请复制时间存储桶，并根据需要更改员工名称。

10. 要置备计划，点 Scheduling 并选择您为其创建轮转的位置。
11. 单击 Provision，再指定日期范围。
12. 取消选择在此计划中包括的位置。
13. 单击所选 spot 旁边的箭头，然后取消选择希望在您的计划中使用的任何时间存储桶。
14. 单击 Provision Shifts。日历填充自时间存储桶生成的转换。
15. 要修改转变，请点击日历上的生成的转变。

许多企业的主要目的是传输各种类型的车go。这些企业的目标是以最有效的方式从加载点向目标交付一个车点，并使用其载体车队。主要目标之一是尽量缩短以时间或距离度衡量的差差成本。

这种优化问题被称为载体路由问题(VRP)，并具有很多变体。

Red Hat build of OptaPlanner 可解决许多这些载体路由变化并提供解决方案示例。OptaPlanner 可让开发人员专注于对业务规则和需求建模，而不是学习 约束编程。OptaWeb Vehicle Routing 通过提供回答问题的入门应用程序，扩展了 OptaPlanner 的载路由功能：

OptaWeb Vehicle Routing 使用 OpenStreetMap(OSM)数据文件。有关 OpenStreetMap 的详情，请查看 OpenStreetMap 网站。

在使用 OptaWeb Vehicle 路由时，请使用以下定义：

区域 ：sarth 映射上的任意区域，由 OSM 文件表示。地区可以是国家/地区、城市、洲或一组经常一起使用的国家/地区。例如，DACH 区域包括德国(DE)、奥地利(AT)和瑞士(CH)。

国家/ 地区代码：由 ISO-3166 标准分配给国家的双字母代码。您可以使用国家代码过滤 geosearch 结果。由于您可以处理跨越多个国家（例如 DACH 区域）的区域，OptaWeb Vehicle Routing 接受国家代码列表，以便 geosearch 过滤可与此类区域一起使用。有关 国家代码列表，请参阅 ISO 3166 country Codes

Geosearch ：一个查询类型，在其中提供区域的地址或放置名称作为搜索关键字，并收到多个 GPS 位置。返回的位置数量取决于搜索关键字的唯一情况。因为大多数位置名称没有唯一的，所以通过在您工作区域的国家或国家/地区中包括内容，过滤出非相关结果。

在构建和部署 OptaWeb Vehicle 路由前，您必须下载并准备部署文件。