Question

我现在正致力于为客户创建最经济的时间表（使用最少的替代品）给出以下问题：

替补队员应该连续一次代替老师尽可能（*不是一个大问题）
Subs只能工作6个周期

到目前为止，我有一个Teacher类（如下所示）和一个实际创建最佳计划的Organizer类。现在，我正在为每个替代品填充网格中的程序循环。

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

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

对于此输入，使用的最小子数为9（由P2列约束），因此我想看看是否有任何可能的方法可以完成该数字，或者至少10个潜艇。提前谢谢！

Answer 1

对于每一列，找出有多少个开放空间。

将每个sub放在具有最多空格的列中，然后随机放置。这个算法将用10个子解决你的问题。

在您的具体示例中，有59个空格。假设每个sub只能填充6个空格，10是可以工作的最小数量的subs。我相信它总能找到最佳解决方案。

（我忽略了你连续几天的规则。“然后随机”规则可以用试图优化的东西替换......）

替代调度程序/算法

1 个答案: