Merge branch 'core/recreate-complexity'

CHANGELOG.md

@@ -14,6 +14,7 @@
 
 - Refactor `Matrix` template class (#1089)
 - Refactor to use `std::format` whenever possible (#1081)
+- Reduce complexity for recreation process (#1155)
 
 #### CI
 

src/algorithms/local_search/local_search.cpp

@@ -161,180 +161,98 @@ void LocalSearch<Route,
                  SwapStar,
                  RouteSplit,
                  PriorityReplace,
-                 TSPFix>::try_job_additions(const std::vector<Index>& routes,
-                                            double regret_coeff
+                 TSPFix>::recreate(const std::vector<Index>& routes
 #ifdef LOG_LS
-                                            ,
-                                            bool log_addition_step
+                                   ,
+                                   bool log_addition_step
 #endif
 ) {
-  bool job_added;
+  std::vector<Index> ordered_jobs(_sol_state.unassigned.begin(),
+                                  _sol_state.unassigned.end());
+  std::ranges::sort(ordered_jobs, [this](const Index lhs, const Index rhs) {
+    return _input.jobs[lhs] < _input.jobs[rhs];
+  });
 
-  std::vector<std::vector<RouteInsertion>> route_job_insertions;
-  route_job_insertions.reserve(routes.size());
-
-  for (std::size_t i = 0; i < routes.size(); ++i) {
-    route_job_insertions.emplace_back(_input.jobs.size(),
-                                      RouteInsertion(_input.get_amount_size()));
-
-    const auto v = routes[i];
-    const auto fixed_cost =
-      _sol[v].empty() ? _input.vehicles[v].fixed_cost() : 0;
-
-    for (const auto j : _sol_state.unassigned) {
-      if (const auto& current_job = _input.jobs[j];
-          current_job.type == JOB_TYPE::DELIVERY) {
-        continue;
-      }
-      route_job_insertions[i][j] =
-        compute_best_insertion(_input, _sol_state, j, v, _sol[v]);
+  std::unordered_set<Index> modified_vehicles;
 
-      if (route_job_insertions[i][j].eval != NO_EVAL) {
-        route_job_insertions[i][j].eval.cost += fixed_cost;
-      }
+  for (const auto j : ordered_jobs) {
+    const auto& current_job = _input.jobs[j];
+    if (current_job.type == JOB_TYPE::DELIVERY) {
+      continue;
     }
-  }
 
-  std::unordered_set<Index> modified_vehicles;
-
-  do {
-    Priority best_priority = 0;
     RouteInsertion best_insertion(_input.get_amount_size());
-    double best_cost = std::numeric_limits<double>::max();
-    Index best_job_rank = 0;
-    Index best_route = 0;
-    std::size_t best_route_idx = 0;
+    Index best_v = 0;
 
-    for (const auto j : _sol_state.unassigned) {
-      const auto& current_job = _input.jobs[j];
-      if (current_job.type == JOB_TYPE::DELIVERY) {
+    for (const auto v : routes) {
+      if (const unsigned added_tasks =
+            (current_job.type == JOB_TYPE::PICKUP) ? 2 : 1;
+          _sol[v].size() + added_tasks > _input.vehicles[v].max_tasks) {
         continue;
       }
 
-      const auto job_priority = current_job.priority;
-
-      if (job_priority < best_priority) {
-        // Insert higher priority jobs first.
-        continue;
-      }
+      auto current_best_insertion =
+        compute_best_insertion(_input, _sol_state, j, v, _sol[v]);
 
-      auto smallest = _input.get_cost_upper_bound();
-      auto second_smallest = _input.get_cost_upper_bound();
-      std::size_t smallest_idx = std::numeric_limits<std::size_t>::max();
-
-      for (std::size_t i = 0; i < routes.size(); ++i) {
-        if (route_job_insertions[i][j].eval.cost < smallest) {
-          smallest_idx = i;
-          second_smallest = smallest;
-          smallest = route_job_insertions[i][j].eval.cost;
-        } else if (route_job_insertions[i][j].eval.cost < second_smallest) {
-          second_smallest = route_job_insertions[i][j].eval.cost;
-        }
+      if (current_best_insertion.eval != NO_EVAL && _sol[v].empty()) {
+        current_best_insertion.eval.cost += _input.vehicles[v].fixed_cost();
       }
 
-      // Find best route for current job based on cost of addition and
-      // regret cost of not adding.
-      for (std::size_t i = 0; i < routes.size(); ++i) {
-        if (route_job_insertions[i][j].eval == NO_EVAL) {
-          continue;
-        }
-
-        const auto& current_r = _sol[routes[i]];
-        const auto& vehicle = _input.vehicles[routes[i]];
-
-        if (bool is_pickup = (_input.jobs[j].type == JOB_TYPE::PICKUP);
-            current_r.size() + (is_pickup ? 2 : 1) > vehicle.max_tasks) {
-          continue;
-        }
-
-        const auto regret_cost =
-          (i == smallest_idx) ? second_smallest : smallest;
-
-        const double current_cost =
-          static_cast<double>(route_job_insertions[i][j].eval.cost) -
-          regret_coeff * static_cast<double>(regret_cost);
-
-        if ((job_priority > best_priority) ||
-            (job_priority == best_priority && current_cost < best_cost)) {
-          best_priority = job_priority;
-          best_job_rank = j;
-          best_route = routes[i];
-          best_insertion = route_job_insertions[i][j];
-          best_cost = current_cost;
-          best_route_idx = i;
-        }
+      if (current_best_insertion.eval < best_insertion.eval) {
+        best_insertion = current_best_insertion;
+        best_v = v;
       }
     }
 
-    job_added = (best_cost < std::numeric_limits<double>::max());
+    if (best_insertion.eval == NO_EVAL) {
+      // Current job cannot be inserted.
+      continue;
+    }
 
-    if (job_added) {
-      _sol_state.unassigned.erase(best_job_rank);
+    // Found a valid insertion spot for current job.
+    _sol_state.unassigned.erase(j);
 
-      if (const auto& best_job = _input.jobs[best_job_rank];
-          best_job.type == JOB_TYPE::SINGLE) {
-        _sol[best_route].add(_input, best_job_rank, best_insertion.single_rank);
-      } else {
-        assert(best_job.type == JOB_TYPE::PICKUP);
-
-        std::vector<Index> modified_with_pd;
-        modified_with_pd.reserve(best_insertion.delivery_rank -
-                                 best_insertion.pickup_rank + 2);
-        modified_with_pd.push_back(best_job_rank);
-
-        std::copy(_sol[best_route].route.begin() + best_insertion.pickup_rank,
-                  _sol[best_route].route.begin() + best_insertion.delivery_rank,
-                  std::back_inserter(modified_with_pd));
-        modified_with_pd.push_back(best_job_rank + 1);
-
-        _sol[best_route].replace(_input,
-                                 best_insertion.delivery,
-                                 modified_with_pd.begin(),
-                                 modified_with_pd.end(),
-                                 best_insertion.pickup_rank,
-                                 best_insertion.delivery_rank);
-
-        assert(_sol_state.unassigned.find(best_job_rank + 1) !=
-               _sol_state.unassigned.end());
-        _sol_state.unassigned.erase(best_job_rank + 1);
-      }
+    if (current_job.type == JOB_TYPE::SINGLE) {
+      _sol[best_v].add(_input, j, best_insertion.single_rank);
+    } else {
+      assert(current_job.type == JOB_TYPE::PICKUP);
 
-      // Update best_route data required for consistency.
-      modified_vehicles.insert(best_route);
-      _sol_state.update_route_eval(_sol[best_route].route, best_route);
-      _sol_state.set_insertion_ranks(_sol[best_route], best_route);
+      std::vector<Index> modified_with_pd;
+      modified_with_pd.reserve(best_insertion.delivery_rank -
+                               best_insertion.pickup_rank + 2);
+      modified_with_pd.push_back(j);
+
+      std::copy(_sol[best_v].route.begin() + best_insertion.pickup_rank,
+                _sol[best_v].route.begin() + best_insertion.delivery_rank,
+                std::back_inserter(modified_with_pd));
+      modified_with_pd.push_back(j + 1);
+
+      _sol[best_v].replace(_input,
+                           best_insertion.delivery,
+                           modified_with_pd.begin(),
+                           modified_with_pd.end(),
+                           best_insertion.pickup_rank,
+                           best_insertion.delivery_rank);
+
+      assert(_sol_state.unassigned.find(j + 1) != _sol_state.unassigned.end());
+      _sol_state.unassigned.erase(j + 1);
+    }
 
-      const auto fixed_cost =
-        _sol[best_route].empty() ? _input.vehicles[best_route].fixed_cost() : 0;
-
-      for (const auto j : _sol_state.unassigned) {
-        if (const auto& current_job = _input.jobs[j];
-            current_job.type == JOB_TYPE::DELIVERY) {
-          continue;
-        }
-        route_job_insertions[best_route_idx][j] =
-          compute_best_insertion(_input,
-                                 _sol_state,
-                                 j,
-                                 best_route,
-                                 _sol[best_route]);
-
-        if (route_job_insertions[best_route_idx][j].eval != NO_EVAL) {
-          route_job_insertions[best_route_idx][j].eval.cost += fixed_cost;
-        }
-      }
+    // Update best route data, required for consistency.
+    modified_vehicles.insert(best_v);
+    _sol_state.update_route_eval(_sol[best_v].route, best_v);
+    _sol_state.set_insertion_ranks(_sol[best_v], best_v);
 
 #ifdef LOG_LS
-      if (log_addition_step) {
-        steps.push_back({utils::now(),
-                         log::EVENT::JOB_ADDITION,
-                         OperatorName::MAX,
-                         utils::SolutionIndicators<Route>(_input, _sol),
-                         std::nullopt});
-      }
-#endif
+    if (log_addition_step) {
+      steps.push_back({utils::now(),
+                       log::EVENT::JOB_ADDITION,
+                       OperatorName::MAX,
+                       utils::SolutionIndicators<Route>(_input, _sol),
+                       std::nullopt});
     }
-  } while (job_added);
+#endif
+  }
 
   for (const auto v : modified_vehicles) {
     _sol_state.update_route_bbox(_sol[v].route, v);
@@ -1886,16 +1804,14 @@ void LocalSearch<Route,
 
       for (auto v_rank : update_candidates) {
         // Only this update (and update_route_eval done above) are
-        // actually required for consistency inside try_job_additions.
+        // actually required for consistency inside recreate step.
         _sol_state.set_insertion_ranks(_sol[v_rank], v_rank);
       }
 
-      try_job_additions(best_ops[best_source][best_target]
-                          ->addition_candidates(),
-                        0
+      recreate(best_ops[best_source][best_target]->addition_candidates()
 #ifdef LOG_LS
-                        ,
-                        true
+                 ,
+               true
 #endif
       );
 
@@ -1942,8 +1858,8 @@ void LocalSearch<Route,
         for (auto req_u : best_ops[v][v]->required_unassigned()) {
           if (!_sol_state.unassigned.contains(req_u)) {
             // This move should be invalidated because a required
-            // unassigned job has been added by try_job_additions in
-            // the meantime.
+            // unassigned job has been added by recreate step in the
+            // meantime.
             invalidate_move = true;
             break;
           }
@@ -2046,7 +1962,7 @@ void LocalSearch<Route,
         _sol_state.setup(_sol);
       }
 #ifdef LOG_LS
-      if (_best_sol_indicators < current_sol_indicators or
+      if (_best_sol_indicators < current_sol_indicators ||
           _best_sol_indicators == current_sol_indicators) {
         steps.push_back({utils::now(),
                          log::EVENT::ROLLBACK,
@@ -2090,12 +2006,11 @@ void LocalSearch<Route,
         _sol_state.set_insertion_ranks(_sol[v], v);
       }
 
-      // Refill jobs.
-      constexpr double refill_regret = 1.5;
-      try_job_additions(_all_routes, refill_regret);
+      // Recreate solution
+      recreate(_all_routes);
 
       // Update everything except what has already been updated in
-      // try_job_additions.
+      // recreate step.
       for (std::size_t v = 0; v < _sol.size(); ++v) {
         _sol_state.update_costs(_sol[v].route, v);
         _sol_state.update_skills(_sol[v].route, v);

src/algorithms/local_search/local_search.h

@@ -66,11 +66,10 @@ class LocalSearch {
   std::vector<log::Step<Route>> steps;
 #endif
 
-  void try_job_additions(const std::vector<Index>& routes,
-                         double regret_coeff
+  void recreate(const std::vector<Index>& routes
 #ifdef LOG_LS
-                         ,
-                         bool log_addition_step = false
+                ,
+                bool log_addition_step = false
 #endif
   );
 

src/structures/vroom/job.cpp

@@ -10,8 +10,19 @@ All rights reserved (see LICENSE).
 #include "structures/vroom/job.h"
 #include "utils/helpers.h"
 
+#include <numeric>
+
 namespace vroom {
 
+inline Duration get_tw_length(const std::vector<TimeWindow>& tws) {
+  return std::accumulate(tws.begin(),
+                         tws.end(),
+                         0,
+                         [](auto sum, const auto& tw) {
+                           return sum + tw.length;
+                         });
+};
+
 Job::Job(Id id,
          const Location& location,
          UserDuration setup,
@@ -32,6 +43,7 @@ Job::Job(Id id,
     skills(std::move(skills)),
     priority(priority),
     tws(tws),
+    tw_length(get_tw_length(tws)),
     description(std::move(description)) {
   utils::check_tws(tws, id, "job");
   utils::check_priority(priority, id, "job");
@@ -57,6 +69,7 @@ Job::Job(Id id,
     skills(std::move(skills)),
     priority(priority),
     tws(tws),
+    tw_length(get_tw_length(tws)),
     description(std::move(description)) {
   assert(type == JOB_TYPE::PICKUP || type == JOB_TYPE::DELIVERY);
   utils::check_tws(tws, id, "job");

src/structures/vroom/job.h

@@ -30,6 +30,7 @@ struct Job {
   const Skills skills;
   const Priority priority;
   const std::vector<TimeWindow> tws;
+  const Duration tw_length;
   const std::string description;
 
   // Constructor for regular one-stop job (JOB_TYPE::SINGLE).
@@ -64,6 +65,16 @@ struct Job {
   }
 
   bool is_valid_start(Duration time) const;
+
+  friend bool operator<(const Job& lhs, const Job& rhs) {
+    // Sort by:
+    //   - decreasing priority
+    //   - increasing TW length
+    //   - decreasing delivery amount
+    //   - decreasing pickup amount
+    return std::tie(rhs.priority, lhs.tw_length, rhs.delivery, rhs.pickup) <
+           std::tie(lhs.priority, rhs.tw_length, lhs.delivery, lhs.pickup);
+  }
 };
 
 } // namespace vroom