使用Optaplanner实现课程调度均匀分布的规则咨询

Hey there! Let's walk through how to build this course scheduling solution with OptaPlanner, covering both the mandatory sequence rules and that even distribution goal.

1. First, Lock in the Course Sequence Requirements #

Since your 15 courses have a fixed order they need to follow, this is a hard constraint—meaning it can't be violated. Here's how to model this:

• Add a sequenceRank field to your Course entity (e.g., 1 for the first course, 2 for the second, up to 15).
• Create a constraint that penalizes any scenario where a course with a lower sequenceRank (earlier in the order) is scheduled after a course with a higher rank. Using OptaPlanner's constraint stream API, it might look like this:

constraintFactory.from(Course.class)
    .join(Course.class, 
          Joiners.lessThan(Course::getSequenceRank), 
          Joiners.greaterThan(Course::getScheduledTimeSlot))
    .penalize("Enforce Course Sequence", HardSoftScore.ONE_HARD)
    .asConstraint();

This ensures the order is non-negotiable.

2. Implement Even Distribution of Courses #

For the even spread, this is a soft constraint—we want to prioritize it, but it's flexible if needed. There are two solid approaches here:

Option A: Minimize Interval Variance #

Calculate the ideal time gap between courses first (total available time divided by 14 gaps, since 15 courses have 14 intervals between them). Then penalize any pair of consecutive courses where the actual gap deviates from this ideal. The bigger the deviation, the heavier the penalty:

// Assume you have startTime and endTime defined for your time window
int totalTimeWindow = endTime - startTime;
int idealGap = totalTimeWindow / 14;

constraintFactory.from(Course.class)
    .join(Course.class, Joiners.greaterThan(Course::getScheduledTimeSlot))
    .filter((earlierCourse, laterCourse) -> {
        int actualGap = laterCourse.getScheduledTimeSlot() - earlierCourse.getScheduledTimeSlot();
        return Math.abs(actualGap - idealGap) > 1; // Adjust the tolerance as needed
    })
    .penalize("Evenly Space Courses", HardSoftScore.ONE_SOFT,
        (earlier, later) -> Math.abs((later.getScheduledTimeSlot() - earlier.getScheduledTimeSlot()) - idealGap))
    .asConstraint();

Option B: Discourage Clustering #

If you just want to avoid bunching courses together, add a constraint that penalizes any two courses that are scheduled too close together (relative to the ideal gap). This is simpler if you don't need perfect uniformity, just a spread-out schedule.

You can also add a small soft constraint to push the first course near the start of your time window and the last course near the end, to make sure you're using the full available time.

3. Example Resources to Reference #

While there's no exact 15-course ordered scheduling example in OptaPlanner's official resources, the Conference Scheduling and University Course Scheduling built-in examples are perfect starting points:

• The Conference Scheduling example includes logic for spacing out sessions and managing time slot constraints.
• The University Course Scheduling example covers hard constraints for course ordering and resource allocation.

You can adapt the constraint patterns from these examples to fit your specific needs—just swap out the entities and tweak the constraint logic to match your sequence and distribution goals.

内容的提问来源于stack exchange，提问作者Phil Gillam