Add feature to balance shifts across vehicles

vrp-core/src/construction/features/fleet_usage.rs

@@ -4,6 +4,8 @@
 #[path = "../../../tests/unit/construction/features/fleet_usage_test.rs"]
 mod fleet_usage_test;
 
+use std::collections::HashMap;
+
 use super::*;
 
 /// Creates a feature to minimize used fleet size (affects amount of tours in solution).
@@ -52,6 +54,65 @@ pub fn create_minimize_arrival_time_feature(name: &str) -> GenericResult<Feature
         .build()
 }
 
+/// Creates a feature to distribute shifts evenly across vehicles.
+/// This encourages using different shifts from different vehicles rather than
+/// exhausting all shifts from one vehicle before using another.
+pub fn create_balance_shifts_feature(name: &str) -> GenericResult<Feature> {
+    FeatureBuilder::default()
+        .with_name(name)
+        .with_objective(FleetUsageObjective {
+            route_estimate_fn: Box::new(|_| 0.),
+            solution_estimate_fn: Box::new(|solution_ctx| {
+                if solution_ctx.routes.is_empty() {
+                    return 0.;
+                }
+
+                // Group routes by vehicle ID
+                let mut vehicle_shift_counts: HashMap<String, usize> = HashMap::new();
+                let mut total_available_shifts: HashMap<String, usize> = HashMap::new();
+
+                // Count how many shifts each vehicle is using
+                for route_ctx in solution_ctx.routes.iter() {
+                    let actor = &route_ctx.route().actor;
+                    if let Some(vehicle_id) = actor.vehicle.dimens.get_vehicle_id() {
+                        *vehicle_shift_counts.entry(vehicle_id.clone()).or_insert(0) += 1;
+
+                        // Track total available shifts for this vehicle
+                        total_available_shifts.entry(vehicle_id.clone()).or_insert(actor.vehicle.details.len());
+                    }
+                }
+
+                // Calculate the imbalance score
+                // We want to minimize the variance of (used_shifts / available_shifts) ratio
+                if vehicle_shift_counts.is_empty() {
+                    return 0.;
+                }
+
+                let ratios: Vec<f64> = vehicle_shift_counts
+                    .iter()
+                    .map(|(vehicle_id, &used_count)| {
+                        let available = *total_available_shifts.get(vehicle_id).unwrap_or(&1) as f64;
+                        used_count as f64 / available
+                    })
+                    .collect();
+
+                // Calculate variance of ratios
+                let mean: f64 = ratios.iter().sum::<f64>() / ratios.len() as f64;
+                let variance: f64 = ratios
+                    .iter()
+                    .map(|&ratio| {
+                        let diff = ratio - mean;
+                        diff * diff
+                    })
+                    .sum::<f64>()
+                    / ratios.len() as f64;
+
+                variance
+            }),
+        })
+        .build()
+}
+
 struct FleetUsageObjective {
     route_estimate_fn: Box<dyn Fn(&RouteContext) -> Cost + Send + Sync>,
     solution_estimate_fn: Box<dyn Fn(&SolutionContext) -> Cost + Send + Sync>,

vrp-pragmatic/src/format/problem/goal_reader.rs

@@ -149,6 +149,7 @@ fn get_objective_feature_layer(
             }),
             ViolationCode::unknown(),
         ),
+        Objective::BalanceShifts => create_balance_shifts_feature("balance_shifts"),
         Objective::MinimizeUnassigned { breaks } => MinimizeUnassignedBuilder::new("min_unassigned")
             .set_job_estimator({
                 let break_value = *breaks;

vrp-pragmatic/src/format/problem/model.rs

@@ -572,6 +572,9 @@ pub enum Objective {
     /// An objective to balance duration across all tours.
     BalanceDuration,
 
+    /// An objective to balance shifts across all vehicles.
+    BalanceShifts,
+
     /// An objective to control how tours are built.
     CompactTour {
         /// Specifies radius of neighbourhood. Min is 1.