规划问题 具有最佳目标，基于有限的资源和特定限制。最佳目标可以是任意数量的内容，例如：

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

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

红帽构建的 OptaPlanner 帮助 Java 编程人员有效地解决约束问题。它结合了优化 heuristics 和 metaheuristics 与有效的分数计算。

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

这意味着，解决您的问题可能比您期望的更难，因为两种常见的技术不可靠：

通过使用高级优化算法，OptaPlanner 在这类规划问题合理时间内找到了很好的解决方案。

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

几种解决方案类别有：

Counterintuitive，可能的解决方案数量是很大（如果正确计算），即使数据集小也是如此。

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

OptaPlanner 支持多种优化算法，通过非常广泛的可能的解决方案来高效地偏离。

根据用例，一些优化算法的性能优于其他算法，但无法提前了解。使用 OptaPlanner，您可以通过更改 XML 或代码的几行中的 solver 配置来切换优化算法。

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

有些问题也具有正限制：

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

这些限制定义了规划问题 的分数计算 （也称为适合 函数）。规划问题的每个解决方案均以分数的形式进行评分。使用 OptaPlanner 时，分数限制使用面向对象的语言（如 Java）或 Drools 规则编写。

这种代码非常灵活且可扩展的。

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

某些 OptaPlanner 示例解决了在紧张中呈现的问题。下表中的就列列出了 contests。它还将示例识别为 现实 或非现实。真实的 contest 是符合以下标准的官方独立调查：

real real contests 提供 OptaPlanner 与竞争软件和学术研究的目标比较。

在 n sized chessboard 上放置 N 个queens 数量，因此没有两个 queens 相互攻击。最常见的 n queens puzzle 是八个 queens puzzle，n = 8 ：

约束：

本文档主要使用 4 queens puzzle 作为主要示例。

建议的解决方案可以是：

图 3.1. 错误解决方案，用于 4 queens puzzle

以上解决方案错误，因为 queens A1 和 B0 可以相互攻击（从而可以相互攻击 B0 和 D0）。删除 queen B0 会遵守"无两个 queens 可相互攻击"约束，但可能会破坏"place n queens"约束。

以下是正确的解决方案：

图 3.2. 用于 Four queens puzzle 的正确解决方案

满足了所有限制，因此解决方案正确。

请注意，最多 n queens puzzles 具有多个正确的解决方案。我们将专注于为特定 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 个问题。随着一些更改，它已被显示，可以轻松地处理 5000 频率等。

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 is column B, …​） 和一个 Row （例如，0 一行，1 为行 1, …​）。

  可以按列和行计算升序诊断行和降序诊断行。

  列和行索引从 chessboard 的左上角启动。

  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 实例的列表。它是提供给、解决并从 Solver 检索的解决方案实施。

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

图 3.3. Four Queens 的解决方案

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

	columnIndex	rowIndex	atingDiagonalIndex (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 共享同一列时，行或诊断行，如 principal 和(**)，他们可以相互攻击。

有关此示例的详情，请参考 红帽构建的 OptaPlanner 快速启动指南。

考虑到城市列表，请找到获得每个城市完全访问的销售人员的最短产品。

这个问题由 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 均有四个团队互相扮演循环。为团队随机分配这四个点。

硬限制：

中型限制：

软限制：

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

图 3.4. 域模型

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

硬限制：

中型限制：

软限制：

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. 域模型

使用一组车辆，获取每个客户的对象并将其引入独立。每个 vehicle 都可以服务于多个客户，但其容量有限。

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

硬限制：

软限制：

capacitated vehicle 路由问题(CVRP)及其定时序变体(CVRPTW)由 VRP Web 定义。

图 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.

CVRPTW 实例（有时间窗）：

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 路由的域模型

带有时间窗域模型的载体路由大量使用影子变量功能。这样，它可以更加自然地表达其约束，因为 arrivalTime 和 departureTime 等属性在域模型上直接可用。

road Distances Instead of Air Distances

在现实世界中，vehicles 无法直接跟随位置到位置：他们必须使用路线和高路。从业务角度来看，这很重要：

对于优化算法，这无关紧要，只要可以查找两个点之间的距离（最好是预先计算的）。路线成本甚至不需要距离。它还可以是出差时间、控制成本或其加权的功能。有多种技术可用于预先计算路线成本，如 GraphHopper （可能，离线 Java 引擎）、Open MapQuest (web service)和 Google Maps Client API (web 服务)。

另外，还有多种技术可供开发人员呈现，如 Leaflet 和 Google Maps。

甚至可以使用 GraphHopper 或 Google Map Directions 呈现实际的路线图路由，但由于路由在高方面重叠，因此查看独立顺序可能会变得困难：

请特别注意两点之间的路线成本使用与 OptaPlanner 中使用的优化标准相同的优化标准。例如，G GraphHopper 默认返回最快的路由，而不是最短的路由。不要使用最快的 GPS 路由的 km （或 miles）来优化 OptaPlanner 中的最短往返：这会带来子优化的解决方案，如下所示：

最受欢迎的是，大多数用户都不希望最短的路由：他们希望获得最快的路由。他们更喜欢比普通路线的高路。他们更喜欢使用 dirt 路线的正常路。在现实世界中，最快速和最短的路由很少相同。

以时间和执行模式调度所有作业，以最小化项目延迟。每个作业都是一个项目的一部分。某个作业可以以不同的方式执行：每个执行模式都是一个执行模式，这意味着不同的持续时间，但也有不同的资源使用量。这是灵活的 作业跃点调度的一种形式。

硬限制：

中型限制：

软限制：

这个问题由 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.

将每个任务分配到员工队列中的位置。每个任务都有一个持续时间，受员工的关联级别与任务的客户影响。

硬限制：

软级别 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 的早期版本完成 4 个竞争。自那时起，我们做出了很多改进。

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 年国际子公司定义。

图 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.

以时间和计算机上计划所有任务，以最大程度降低功耗。电源价格因时间不同。这是 作业跃点调度的一种形式。

硬限制：

中型限制：

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

问题由 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 可能会重叠。从使用 libreoffice 或 Excel 编辑的 *.xlsx 文件中读取和写入。

硬限制：

软限制：

图 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.

从 show to show 驱动 rock 银行总线，但时间表仅在可用天显示。

硬限制：

中型限制：

软限制：

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 包括多个示例项目，可用于熟悉产品及其功能。员工漫长示例项目旨在并创建来演示红帽构建 OptaPlanner 的转变激情用例。使用以下流程在 Business Central 中部署和运行员工名词示例。

本文档的其余部分解释了每个项目资产及其配置。

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

您可以创建员工对示例"从零开始"。您可以使用本例中的工作流在 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. 指导规则

指导规则是在 Business Central 中的基于 UI 的引导规则设计程序中创建的业务规则，引导您通过规则创建流程。指导规则设计程序根据所定义的规则的数据对象提供可接受的输入字段和选项。您定义的指导规则被编译到 Drools 规则语言(DRL)规则中，与所有其他规则资产一样。

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

5.2.5.2. 创建指导规则来平衡员工的改变数字

BalanceEmployeesShiftNumber 指导规则创建一个软约束，以确保按尽可能平均平衡的方式分配到员工。它通过创建一个在变换发行版时增加的分数损失来达到此目的。分数公式由规则实施，以更均衡的方式替换 Solver 分发变化。

流程

1. 在 Business Central 中，前往 Menu → Design → Projects，再单击项目名称。
2. 点 Add Asset → Guided Rule。
3. 输入 BalanceEmployeesShiftNumber 作为" 指导规则名称"，然后选择 employeerostering.employeerostering Package。
4. 点 Ok 创建规则资产。
5. 点 WHEN 字段中的 来添加 WHEN 条件。
6. 在 Add a condition to the rule 窗口中选择 Employee。单击 +Ok。
7. 点 Employee 条件来修改约束，并添加变量名称 $employee。

8. 从 累积 中添加 WHEN 条件。

   1. 在 From A umulate 条件 上方，单击添加模式，然后从下拉列表中选择 Number 作为事实类型。
   2. 将变量名称 $shiftCount 添加到 Number 条件。
   3. 在 From Accumulate 条件下，单击添加模式，然后从下拉列表中选择 ShiftAssignment 事实类型。
   4. 将变量名称 $shiftAssignment 添加到 ShiftAssignment 类型。
   5. 再次单击 ShiftAssignment 条件，然后从 字段下拉列表中的 Add a limit，选择 employee。
   6. 从 员工 约束旁边的下拉列表中，选择 等于。
   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 指导规则创建硬约束，使员工不会每天分配多个变化。在 employee rostering 示例中，这个约束使用指导规则设计程序创建。

流程

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

7. 在 free 表单 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. 在 free 表单 DRL 框中，输入以下条件：

    scoreHolder.addHardConstraintMatch(kcontext, -1);

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

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

5.2.5.4. 创建指导规则来匹配转换要求

ShiftReqiredSkillsAreMet 指导规则会创建一个硬约束，确保为员工分配有正确技能集的员工。在 employee rostering 示例中，这个约束使用指导规则设计程序创建。

流程

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

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

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

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

    1. 在设计人员中，[not bound] 旁边，从第一个下拉列表中选择 员工，然后从下一下拉列表中选择员工。
    2. 将下一个下拉列表保留为 Choose。
    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 指导规则创建一个软约束。通过这个约束，当最初分配该转换的员工不再能够工作时，可以将转换重新分配给另一个员工。在 employee rostering 示例中，这个约束使用指导规则设计程序创建。

流程

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

7. 在 free 表单 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. 在 free 表单 DRL 框中，输入以下条件：

    scoreHolder.addSoftConstraintMatch(kcontext, -100);

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

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

在部署或重新创建示例解析程序后，您可以使用 REST API 访问它。

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

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 目录结构的典型项目中，在使用 Solver Factory 构建 SolverFactory 实例后，solverConfig XML 文件位于 $PROJECT_DIR/src/main/resources/org/optaplanner/examples/<PROJECT>/solver 目录，其中 &lt ;PROJECT > 是您的 OptaPlanner 项目的名称。或者，您可以使用 SolverFactory .createFromXmlFile （）从文件创建 SolverFactory。但是，出于可移植性的原因，建议使用 classpath 资源。

Solver 和 SolverFactory 都有一个称为 Solution_ 的通用类型，即代表计划问题和解决方案的类。

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

您可以使用 SolverConfig API 配置 solver。这对在运行时动态更改值特别有用。以下示例在 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();

solver 配置 XML 文件中的每个元素都作为 Config 类或软件包命名空间 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 使用反射访问您的域。reflection 是可靠的，但与直接访问相比会较慢。或者，您可以将 OptaPlanner 配置为使用 Gizmo 访问您的域，这将生成字节码直接访问域的字段和方法，而无需反映。但是，此方法有以下限制：

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

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

使用问题解决计划问题。

以下示例解决了 NQueens 问题：

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

在本例中，solve （） 方法将返回一个 NQueens 实例，每 Queen 分配给一个 Row。

图 8.1. 在 8ms (Also a Optimal Solution)中 Four Queens Puzzle 最佳解决方案。

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

通过解决环境模式，您可以检测实施中的常见错误。它不会影响日志级别。

解决者只有一个随机实例。有些解析器配置使用随机实例。例如，Simulated Annealing 算法高度依赖于随机数字，而 Tabu Search 仅依赖于它来解析分数。环境模式会影响该随机实例的 seed。

您可以在 solver 配置 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 中的日志级别来查看 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，这是一个简单的日志记录传真，它将每个日志消息委派给 Logback、Apache Commons Logging、Log4j 或 java.util.logging。为您的日志记录框架添加依赖项到日志记录适配器。

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

如果您已在使用 Log4J，且您不想切换到更快的成功者 Logback，您可以为 Log4J 配置 OptaPlanner 项目。

OptaPlanner 通过 Micrometer (Java 应用程序的指标检测库)公开指标。您可以使用带有流行监控系统的 Micrometer 来监控 OptaPlanner 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 timetable 项目旨在为每个时间插槽和房间分配。要做到这一点，添加三个类、Timeslot、Lesson 和 Room，如下图所示：

时间插槽没有日期，因为高校的计划仅每周重复。不需要 持续规划。一个时间被认为是个问题，因为在解决 过程中，实例不会发生改变。此类类不需要任何特定于 OptaPlanner 的注解。

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

在解决期间，OptaPlanner 会改变下课的计时和 房间 字段，以将每个上课时间分配到一个时间插槽和房间。 因为 OptaPlanner 更改了这些字段，所以 Lesson 是一个 计划实体 ：

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

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

因为 timetable 示例用例有硬和软限制，所以使用 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)的 magnitude 顺序。

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 实例将单个数据集的所有 Timeslot、Room 和 Lesson 实例包装。此外，由于它包含所有经验，因此每个均具有特定的计划变量状态，因此它是一个 规划解决方案，它分数如下：

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 注释。

timeslotList 和 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;
    }

}

初始实施会等待 solver 完成，这仍可能导致 HTTP 超时。完整的实施避免了 HTTP 超时非常明显。

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

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

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

良好的应用程序包括测试覆盖。测试时间表项目中的限制和 solver。

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 Timetable 项目后，您可以使用日志信息来帮助微调 ConstraintProvider 中的限制。查看 info 日志文件中的分数计算速度，以评估更改对您的限制的影响。以 debug 模式运行应用程序，以显示应用程序接受的每个步骤或使用 trace 日志记录来记录每个步骤和每次移动。

创建 Quarkus OptaPlanner respectively Timetable 应用程序后，您可以将它与数据库集成，并创建一个基于 web 的用户界面来显示可的时间。

OptaPlanner 通过 Micrometer (Java 应用程序的指标检测库)公开指标。您可以将 Micrometer 与 Prometheus 搭配使用，以监控 button Timetable 应用程序中的 OptaPlanner solver。

调度点的方法主要有两种。系统可以让个人选择一个代表插槽（用户选择）或者系统分配一个插槽，并告知个人何时和在哪里参加（系统自动分配系统）。OptaPlanner vaccination appointment 调度程序使用 system-automaticly-assigns 方法。使用 OptaPlanner vaccination appointment 调度程序，您可以创建一个应用程序来向系统提供信息，系统会分配 appointment。

这种方法的特性：

这种方法通过使用规划限制为每个人创建分数来解决尽可能多的人问题。个人分数决定了它们何时获得代表。个人分数越大，他们获得较早收到的成效几率就越好。

11.1.2. OptaPlanner solver

在 OptaPlanner 的核心是解决者，使用问题数据集并覆盖计划限制和配置引擎。问题数据集包括有关人员、vaccines 和 vaccination 中心的所有信息。解决者通过各种数据组合进行工作，最终决定使用分配给特定中心 vaccination appointments 的人员优化点时间表。以下图显示了解决者创建的调度：

11.1.3. 持续规划

持续规划是同时管理一个或多个即将进行的计划周期的技术，并重复每个进程每月、每周、每天、每小时甚至更频繁的计划周期。计划窗口按指定间隔逐步推进。以下图显示了每日更新的两周规划窗口：

两周的规划窗口被分为一半。第一周处于 published 状态，第二周处于草案状态。人们在规划窗口的已发布和草案部分被分配。但是，只有发布的计划窗口部分中的人员才会通知其标点。其它声明仍可在下一次运行时轻松更改。这样做可让 OptaPlanner 在再次运行解决方案时更改草案部分（如有必要）。例如，如果需要第二个确实有一周的准备日期，并且是星期三的理想日期，OptaPlanner 不必为下称，如果您可以证明 OptaPlanner 可以演示它可以在稍后的星期几内给出一个草案。

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

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

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

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

要查看红帽使用 Spring Boot 产品的 OptaPlanner 构建 OptaPlanner 项目的完整示例，请从红帽客户门户网站下载初学者应用程序。

红帽构建的 OptaPlanner timetable 项目旨在为每个时间插槽和房间分配。要做到这一点，添加三个类、Timeslot、Lesson 和 Room，如下图所示：

时间插槽没有日期，因为高校的计划仅每周重复。不需要 持续规划。一个时间被认为是个问题，因为在解决 过程中，实例不会发生改变。此类类不需要任何特定于 OptaPlanner 的注解。

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

在解决期间，OptaPlanner 会改变下课的计时和 房间 字段，以将每个上课时间分配到一个时间插槽和房间。 因为 OptaPlanner 更改了这些字段，所以 Lesson 是一个 计划实体 ：

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

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

因为 timetable 示例用例有硬和软限制，所以使用 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)的 magnitude 顺序。

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 实例将单个数据集的所有 Timeslot、Room 和 Lesson 实例包装。此外，由于它包含所有经验，因此每个均具有特定的计划变量状态，因此它是一个 规划解决方案，它分数如下：

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 注释。

timeslotList 和 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;
    }

}

在本例中，初始实现会等待 solver 完成，这仍可能导致 HTTP 超时。完整的 实施避免了 HTTP 超时非常明显。

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

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

完成 Red Hat build of 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 搭配使用，以监控 button Timetable 应用程序中的 OptaPlanner solver。

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

红帽构建的 OptaPlanner timetable 项目旨在为每个时间插槽和房间分配。要做到这一点，添加三个类、Timeslot、Lesson 和 Room，如下图所示：

时间插槽没有日期，因为高校的计划仅每周重复。不需要 持续规划。一个时间被认为是个问题，因为在解决 过程中，实例不会发生改变。此类类不需要任何特定于 OptaPlanner 的注解。

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

在解决期间，OptaPlanner 会改变下课的计时和 房间 字段，以将每个上课时间分配到一个时间插槽和房间。 因为 OptaPlanner 更改了这些字段，所以 Lesson 是一个 计划实体 ：

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

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

因为 timetable 示例用例有硬和软限制，所以使用 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)的 magnitude 顺序。

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 实例将单个数据集的所有 Timeslot、Room 和 Lesson 实例包装。此外，由于它包含所有经验，因此每个均具有特定的计划变量状态，因此它是一个 规划解决方案，它分数如下：

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 注释。

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

lessonList 具有 @PlanningEntityCollectionProperty 注释，因此 OptaPlanner 可以在解决问题期间更改它们，并且您的 TimeTableConstraintProvider 也可以从这些注释中选择。

创建了 school timetable 应用程序的所有组件后，您将在 TimeTableApp.java 类中将它们全部放在一起。

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

通常，应用程序有一个 SolverFactory 来为要解决的每个问题数据构建一个新的 Solver 实例。SolverFactory 是 thread-safe，但 Solver 并不是。对于中学时间的应用程序，只有一个数据集，因此只有一个 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 （） 方法生成可计时问题来解决此问题。

printTimetable （） 方法对控制台而言是非常好的打印，因此可以轻松地确定是否是很好的调度。

既然您已完成了本校紧张 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).

良好的应用程序包括测试覆盖。测试时间表项目中的限制和 solver。

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 Timetable 项目后，您可以使用日志信息来帮助微调 ConstraintProvider 中的限制。查看 info 日志文件中的分数计算速度，以评估更改对您的限制的影响。以 debug 模式运行应用程序，以显示应用程序接受的每个步骤或使用 trace 日志记录来记录每个步骤和每次移动。

OptaPlanner 通过 Micrometer (Java 应用程序的指标检测库)公开指标。您可以将 Micrometer 与 Prometheus 搭配使用，以监控 button Timetable 应用程序中的 OptaPlanner solver。

员工漫长的入门应用程序为员工分配在组织中各种位置的转变。例如，您可以使用应用程序在国内、保护在多个位置间转移转移，或在工作程序之间的配配线上切换。

最佳员工必须考虑多个变量。例如，不同位置中的改变需要不同的技能。另外，一些员工可能对一些时间插槽不可用，或者可能选择特定的时间插槽。此外，员工可以拥有合同，限制员工在一个时间段内工作的小时数。

对于这个初学者应用程序，红帽构建的 OptaPlanner 规则都使用硬和软限制。在优化过程中，计划引擎可能无法违反硬约束，例如，如果员工不可用(out sick)，或者员工无法在单个变化中工作两个点。计划引擎会尝试遵循软限制，如员工优先处理特定变化，但如果最佳解决方案需要，可以违反它们。

您可以从源代码构建员工 rostering 初学者应用，并将其作为 JAR 文件运行。

或者，您可以使用您的 IDE （包括 Red Hat CodeReady Studio）来构建和运行应用程序。

员工的初学者应用程序由以下主要组件组成：

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

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

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

要修改员工漫长的初学者应用程序，您必须更改管理优化过程的规则。您还必须确保数据结构包含所需的数据，并为规则提供所需的计算。如果用户界面中没有所需的数据，还必须修改用户界面。

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

员工漫长的入门应用程序为员工分配在组织中各种位置的转变。例如，您可以使用应用程序在国内、保护在多个位置间转移转移，或在工作程序之间的配配线上切换。

最佳员工必须考虑多个变量。例如，不同位置中的改变需要不同的技能。另外，一些员工可能对一些时间插槽不可用，或者可能选择特定的时间插槽。此外，员工可以拥有合同，限制员工在一个时间段内工作的小时数。

对于这个初学者应用程序，红帽构建的 OptaPlanner 规则都使用硬和软限制。在优化过程中，计划引擎可能无法违反硬约束，例如，如果员工不可用(out sick)，或者员工无法在单个变化中工作两个点。计划引擎会尝试遵循软限制，如员工优先处理特定变化，但如果最佳解决方案需要，可以违反它们。

使用 runOnOpenShift.sh 脚本将 Employee Rostering 初学者应用程序部署到 Red Hat OpenShift Container Platform。runOnOpenShift.sh shell 脚本可在 Red Hat Process Automation Manager 7.12.0 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. 查看和编辑轮转模式

轮转模式允许您添加、移动和删除转换，以便您可以有效地管理员工资源。它通过时间 bucket 和席位定义。

• 一个时间存储桶描述了一个时间插槽（例如，上午 9 点到下午 5 点到下午 5:00），用于特定位置或位置 (A) （例如，分析），超过两个或多个天数，以及任何所需技能（例如，触发培训）。
• 席位 (B) 是特定时间 bucket 中特定日期的员工分配。
• employee stub 是一个图标，代表可分配给一个时间 bucket 的员工。员工存根列表 列在 Employee Stub 列表中。

有关轮转模式的详情，请参考 第 15.3.2 节 “轮转模式”。

流程

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

9. 单击鼠标并拖到时间存储桶的座位，以将所选员工分配到这些席位。席位填充员工图标。

   注意

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

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

许多企业的主要目的是传输各种类型的 cargo。这些企业的目标是从加载点向目的地提供一段回车，并以最有效的方式使用其车队。主要目标之一是最大程度减少以时间或距离计算的差旅成本。

这种类型的优化问题被称为 vehicle 路由问题(VRP)，其变化有许多。

红帽构建的 OptaPlanner 可以解决许多这样的 vehicle 路由变化并提供解决方案示例。通过 OptaPlanner，开发人员可以专注于对业务规则和需求建模，而不是学习 约束编程。OptaWeb Vehicle Routing 通过提供回答问题（如下所示）来扩展 OptaPlanner 的 vehicle 路由功能：

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

使用 OptaWeb Vehicle Routing 时使用以下定义：

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

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

Geosearch ：作为搜索关键字提供地址或区域位置名称的查询类型，并因此收到多个 GPS 位置。返回的位置数量取决于搜索关键字的唯一位置。因为大多数位置名称并不是唯一的，因此只包括位于您所在地区或国家/地区中的位置，从而过滤不相关的结果。

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