OptaPlanner处理无法分配的规划实体：实现过约束规划与可空规划变量

import org.optaplanner.core.api.domain.entity.PlanningEntity;
import org.optaplanner.core.api.domain.variable.PlanningVariable;

@PlanningEntity
public class Appointment {

    private String uuid;
    private long startTime;
    private long endTime;
    // ... 其他预约属性

    // 销售代表是规划变量
    private SalesRep salesRep; 

    // 配置 salesRep 为可空规划变量
    @PlanningVariable(valueRangeProviderRefs = {"salesRepRange"}, nullable = true)
    public SalesRep getSalesRep() {
        return salesRep;
    }

    public void setSalesRep(SalesRep salesRep) {
        this.salesRep = salesRep;
    }

    // ... getters and setters for other fields
}

import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
import org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import org.optaplanner.core.api.score.stream.Constraint;
import org.optaplanner.core.api.score.stream.ConstraintFactory;
import org.optaplanner.core.api.score.stream.Joiners;

public class RepSchedulerConstraintProvider implements ConstraintProvider {

    @Override
    public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
        return new Constraint[]{
                repConflict(constraintFactory),
                penalizeUnassignedAppointment(constraintFactory) // 新增的软约束
        };
    }

    Constraint repConflict(ConstraintFactory constraintFactory) {
        // 一个销售代表不能在同一时间段内处理多个预约。
        return constraintFactory
                // 选择每对不同的预约...
                .forEachUniquePair(Appointment.class,
                        Joiners.equal(Appointment::getSalesRep)) // 注意这里是 getSalesRep
                .filter((appt1, appt2) -> {
                    // 如果任一预约未分配，则不检查冲突
                    if (appt1.getSalesRep() == null || appt2.getSalesRep() == null) {
                        return false; 
                    }
                    // 检查时间冲突
                    boolean appt1StartsBeforeAppt2Ends = appt1.getStartTime() < appt2.getEndTime();
                    boolean appt2StartsBeforeAppt1Ends = appt2.getStartTime() < appt1.getEndTime();
                    // 如果两个预约的时间段有重叠，则返回 true 表示冲突
                    return appt1StartsBeforeAppt2Ends && appt2StartsBeforeAppt1Ends;
                })
                // ...并对每个冲突对施加硬惩罚。
                .penalize(HardSoftScore.ONE_HARD)
                .asConstraint("SalesRep conflict");
    }
}

// 在 RepSchedulerConstraintProvider 中添加
Constraint penalizeUnassignedAppointment(ConstraintFactory constraintFactory) {
    return constraintFactory.forEach(Appointment.class)
            .filter(appointment -> appointment.getSalesRep() == null) // 筛选出未分配销售代表的预约
            .penalize(HardSoftScore.ONE_SOFT) // 对每个未分配的预约施加软惩罚
            .asConstraint("Penalize unassigned appointment");
}

// 奖励成功分配的预约 (Alternative to penalizing unassigned)
Constraint rewardAssignedAppointment(ConstraintFactory constraintFactory) {
    return constraintFactory.forEach(Appointment.class)
            .filter(appointment -> appointment.getSalesRep() != null) // 筛选出已分配销售代表的预约
            .reward(HardSoftScore.ONE_SOFT) // 对每个已分配的预约施加软奖励
            .asConstraint("Reward assigned appointment");
}

SolverFactory<RepRoutingSolution> solverFactory = SolverFactory.create(new SolverConfig()
                .withSolutionClass(RepRoutingSolution.class)
                .withEntityClasses(Appointment.class)
                .withConstraintProviderClass(RepSchedulerConstraintProvider.class)
                .withTerminationConfig(new TerminationConfig()
                        .withBestScoreFeasible(true) // 确保最终解是可行的
                )
                .withTerminationSpentLimit(Duration.ofSeconds(5)));