Java 替代调度程序/算法

我现在正在为一个客户解决以下问题，该客户将创建最经济的时间表，并使用最少的替代品，因为：

替代者应连续一段时间代替教师工作 尽可能，这不是一个大问题 潜艇只能工作6个周期 到目前为止，我有一个如下图所示的教师班和一个组织者班，它们实际上创造了最佳的时间表。现在我只是让程序在网格上循环，为每个替换项填充

Teacher[] t= new Teacher[14];
Organizer o = new Organizer(t);         
o.sort();

int[][] g = o.getGrid();

输入示例：

t[0] = new Teacher("Teacher 1", "Mr", new int[]{1,0,1,0,0,0,0});
t[1] = new Teacher("Teacher 2","Mr", new int[]{1,1,0,1,1,0,1});
t[2] = new Teacher("Teacher 3","Mr", new int[]{0,1,1,1,1,1,0});
t[3] = new Teacher("Teacher 4","Mr", new int[]{1,1,0,1,1,0,1});
t[4] = new Teacher("Teacher 5","Mr", new int[]{1,1,0,0,1,1,1});
t[5] = new Teacher("Teacher 6", "Mr", new int[]{1,1,1,0,0,1,1});
t[6] = new Teacher("Teacher 7", "Mr", new int[]{0,0,1,0,1,1,1});
t[7] = new Teacher("Teacher 8", "Mr", new int[]{1,1,0,0,1,1,1});
t[8] = new Teacher("Teacher 9", "Mr", new int[]{1,1,1,1,1,0,0});
t[9] = new Teacher("Teacher 10", "Mr", new int[]{0,0,0,1,1,1,0});
t[10] = new Teacher("Teacher 11", "Mr", new int[]{0,0,1,0,0,1,1});
t[11] = new Teacher("Teacher 12", "Mr", new int[]{0,0,1,1,0,1,0});
t[12] = new Teacher("Teacher 13", "Mr", new int[]{1,1,1,1,0,0,0});
t[13] = new Teacher("Teacher 14", "Mr", new int[]{1,1,0,1,1,0,1});

我使用的算法的上述输出：

                    P1  P2  P3  P4  P5  P6  P7
Teacher 1           1   -   1   -   -   -   -
Teacher 2           2   1   -   1   1   -   1
Teacher 3           -   2   2   2   2   2   -
Teacher 4           3   3   -   3   3   -   3
Teacher 5           4   4   -   -   4   3   4
Teacher 6           5   5   4   -   -   4   5
Teacher 7           -   -   5   -   5   5   6
Teacher 8           6   6   -   -   6   6   7
Teacher 9           7   7   6   7   7   -   -
Teacher 10          -   -   -   8   8   7   -
Teacher 11          -   -   8   -   -   8   8
Teacher 12          -   -   9   9   -   9   -
Teacher 13          8   9   10  10  -   -   -
Teacher 14          9   10  -   11  9   -   10

正如你所看到的，这个程序只是在有效的空间中循环，用sub填充它们，直到sub达到它的最大教学周期，然后开始一个新的sub。问题是，我已经能够在手工操作时将sub的数量减少到10个，所以我一直在试图找到一个更有效的算法，但没有用

---

对于这个输入，使用的sub的最小数量是9，受P2列的限制，所以我想看看是否有任何可能的方法可以实现这个数量，或者至少10个sub。提前谢谢

计算每列的开放空间数量

首先将每个子对象放置到具有最多开放空间的列中，然后随机放置。此算法将用10个子集解决给定问题

在您的特定示例中，有59个空格。假设每个接头只能填充6个空间，10是可以工作的接头的最小数量。我相信它总会找到一个最佳的解决方案

我忽略了你的连续工作日规则。然后随机规则可以被试图优化的东西所取代