Struct ListCheapestInsertionPhase 

pub struct ListCheapestInsertionPhase<S, E>
where
    S: PlanningSolution,
    E: Copy + PartialEq + Eq + Hash + Send + Sync + 'static,
{ /* private fields */ }

List construction phase using greedy cheapest insertion.

For each unassigned element (in index order), evaluates all possible insertion positions across all entities and inserts it at the position that yields the best score. This is significantly better than round-robin for VRP because:

• Routes are built incrementally with score feedback
• Capacity constraints influence which vehicle receives each visit
• Distance/duration constraints are optimized at the point of insertion

Algorithm

for each unassigned element e:
    for each entity r and each position p in r:
        try insert(e, r, p), score, undo
    permanently insert e at (r*, p*) with best score

Complexity: O(E × N × M) where E = elements, N = entities, M = avg route length.

Example

use solverforge_solver::ListCheapestInsertionPhase;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

#[derive(Clone)]
struct Vehicle { visits: Vec<usize> }

#[derive(Clone)]
struct Plan { vehicles: Vec<Vehicle>, n_visits: usize, score: Option<SimpleScore> }

impl PlanningSolution for Plan {
    type Score = SimpleScore;
    fn score(&self) -> Option<Self::Score> { self.score }
    fn set_score(&mut self, score: Option<Self::Score>) { self.score = score; }
}

fn list_len(s: &Plan, e: usize) -> usize {
    s.vehicles.get(e).map_or(0, |v| v.visits.len())
}
fn list_insert(s: &mut Plan, e: usize, pos: usize, val: usize) {
    if let Some(v) = s.vehicles.get_mut(e) { v.visits.insert(pos, val); }
}
fn list_remove(s: &mut Plan, e: usize, pos: usize) -> usize {
    s.vehicles.get_mut(e).map(|v| v.visits.remove(pos)).unwrap_or(0)
}

let phase = ListCheapestInsertionPhase::<Plan, usize>::new(
    |p| p.n_visits,
    |p| p.vehicles.iter().flat_map(|v| v.visits.iter().copied()).collect(),
    |p| p.vehicles.len(),
    list_len,
    list_insert,
    list_remove,
    |idx| idx,
    "visits",
    0,
);

Implementations

impl<S, E> ListCheapestInsertionPhase<S, E>

where S: PlanningSolution, E: Copy + PartialEq + Eq + Hash + Send + Sync + 'static,

pub fn new( element_count: fn(&S) -> usize, get_assigned: fn(&S) -> Vec<E>, entity_count: fn(&S) -> usize, list_len: fn(&S, usize) -> usize, list_insert: fn(&mut S, usize, usize, E), list_remove: fn(&mut S, usize, usize) -> E, index_to_element: fn(usize) -> E, variable_name: &'static str, descriptor_index: usize, ) -> Self

Creates a new cheapest insertion phase.

Arguments

• element_count - Total number of elements to assign
• get_assigned - Returns currently assigned elements
• entity_count - Total number of entities (routes/vehicles)
• list_len - Length of entity’s list
• list_insert - Insert element at position (shifts right)
• list_remove - Remove element at position (used for undo), returns removed element
• index_to_element - Converts element index to element value
• variable_name - Name of the list variable
• descriptor_index - Entity descriptor index

Trait Implementations

impl<S, E> Debug for ListCheapestInsertionPhase<S, E>

where S: PlanningSolution, E: Copy + PartialEq + Eq + Hash + Send + Sync + 'static,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S, E, D> Phase<S, D> for ListCheapestInsertionPhase<S, E>

where S: PlanningSolution, E: Copy + PartialEq + Eq + Hash + Send + Sync + 'static, D: ScoreDirector<S>,

fn solve(&mut self, solver_scope: &mut SolverScope<'_, S, D>)

Executes this phase.

fn phase_type_name(&self) -> &'static str

Returns the name of this phase type.