Absolutely—Bendable Score is perfect for this exact scenario, since it lets you dynamically flip your optimization priorities when a specific threshold (like too many tasks assigned to dummy vehicles) is crossed. Here's how to implement it to prioritize using idle spare vehicles over minimizing mileage when your system is over-constrained:

Core Concept #

Bendable Score works by defining thresholds where your scoring strategy changes. For your use case, we’ll set a threshold based on the number (or volume) of tasks assigned to dummy vehicles. Below the threshold, keep your original priority of minimizing mileage; above it, shift to prioritize moving dummy tasks to idle spare vehicles—even if that means slightly higher total mileage.

Step-by-Step Implementation #

1. Define Your Threshold #

First, pick a meaningful threshold that signals "too many dummy tasks." This could be:

• A fixed number of tasks (e.g., 5+ tasks on dummies)
• A percentage of total tasks (e.g., 10%+ of all tasks assigned to dummies)
• A dynamic value based on idle spare vehicle count (e.g., if 3 spare trucks are idle, trigger when dummy tasks exceed 3)

2. Adapt Your 3-Tier Scoring to Bendable Logic #

Map your Hard/Medium/Soft tiers to a bendable score structure (most VRP solvers like OptaPlanner support BendableHardSoftScore or similar). Adjust weights based on whether you’re above/below the threshold:

Below Threshold (Normal Mode)

• Hard Constraints: Keep these unchanged (e.g., time window violations, load limits—non-negotiable)
• Medium Constraints: Assign low weight to dummy task penalties (since minimizing mileage is priority)
• Soft Constraints: Assign high weight to total mileage minimization

Above Threshold (Spare Vehicle Activation Mode)

• Hard Constraints: Still unchanged
• Medium Constraints: Boost dummy task penalties to a very high weight (make avoiding dummies a near-hard requirement)
• Soft Constraints: Reduce mileage minimization weight, and add a positive reward for using idle spare vehicles (to incentivize the solver to fill empty trucks)

3. Example Scoring Logic (Pseudocode) #

Here’s how this might look in practice (using OptaPlanner-style scoring):

public BendableHardSoftScore calculateScore(TwvrpSolution solution) {
    // Calculate hard constraints first (non-negotiable)
    int hardScore = 0;
    hardScore -= countTimeWindowViolations(solution) * 10000;
    hardScore -= countOverloadedVehicles(solution) * 10000;

    // Calculate dummy task count and threshold
    int dummyTaskCount = countTasksOnDummyVehicles(solution);
    int threshold = calculateDynamicThreshold(solution); // e.g., idle spare truck count

    int mediumScore = 0;
    int softScore = 0;

    if (dummyTaskCount <= threshold) {
        // Normal mode: prioritize mileage
        softScore -= calculateTotalMileage(solution) * 10;
        mediumScore -= dummyTaskCount * 10; // Low penalty for dummies
    } else {
        // Spare vehicle mode: prioritize filling idle trucks
        mediumScore -= dummyTaskCount * 1000; // Heavy penalty for dummies
        softScore -= calculateTotalMileage(solution) * 1; // Reduce mileage weight
        softScore += countUsedSpareVehicles(solution) * 500; // Reward for using spares
    }

    // Return bendable score: [hard], [medium, soft]
    return BendableHardSoftScore.of(new int[]{hardScore}, new int[]{mediumScore, softScore});
}

Pro Tips for Tuning #

• Test Thresholds: Run simulations with different threshold values to find the point where spare vehicles activate just before dummy tasks get out of hand.
• Gradual Weight Shifts: Instead of a hard on/off switch, adjust weights incrementally as dummy task count increases (e.g., start raising dummy penalties at 3 tasks, max out at 5).
• Track Spare Vehicle Utilization: Add a metric to monitor how often spare vehicles are activated—this helps refine your threshold and weights over time.

This setup will ensure your solver automatically shifts priorities when you need it most: keeping dummy tasks low by using idle trucks instead of defaulting to mileage savings when the system is over-constrained.

内容的提问来源于stack exchange，提问作者linux developer