Merge branch 'enhancement/break-positioning-heuristic'

Author: jcoupey

CHANGELOG.md

@@ -68,6 +68,7 @@
 - Wrong evaluation in `ReverseTwoOpt` (#1271)
 - Misleading error with custom distance matrix (#1281)
 - Wrong distance-based optimization with only custom durations (#1298)
+- Break positioning heuristic shortcoming (#1251)
 
 #### Internals
 

src/structures/vroom/tw_route.cpp

@@ -553,9 +553,8 @@ OrderChoice TWRoute::order_choice(const Input& input,
   }
 
   if (check_max_load && j.type == JOB_TYPE::SINGLE &&
-      (!b.is_valid_for_load(current_load + j.pickup - j.delivery) ||
-       !(j.pickup <= bwd_smallest_breaks_load_margin[v.break_rank(b.id)]))) {
-    // Break won't fit right after job for load reason.
+      !(j.pickup <= bwd_smallest_breaks_load_margin[v.break_rank(b.id)])) {
+    // Break won't fit after job for load reason.
     oc.add_break_first = b.is_valid_for_load(current_load);
     return oc;
   }
@@ -853,14 +852,27 @@ bool TWRoute::is_valid_addition_for_tw(const Input& input,
                                    ? j.services[v_type]
                                    : j.setups[v_type] + j.services[v_type];
 
-    auto oc = order_choice(input,
-                           *current_job,
-                           job_action_time,
-                           b,
-                           current,
-                           next,
-                           current_load,
-                           check_max_load);
+    // Use next info after insertion range for ordering decision,
+    // except if there are still jobs to insert after j, in which case
+    // we might have tighter constraints.
+    auto tighter_next = next;
+    if (current_job + 1 < last_job) {
+      const auto& next_j = input.jobs[*(current_job + 1)];
+
+      assert(next.travel <= next.latest);
+      tighter_next.latest =
+        std::min(next.latest - next.travel, next_j.tws.back().end);
+      tighter_next.travel = v.duration(j.index(), next_j.index());
+    }
+
+    const auto oc = order_choice(input,
+                                 *current_job,
+                                 job_action_time,
+                                 b,
+                                 current,
+                                 tighter_next,
+                                 current_load,
+                                 check_max_load);
 
     if (!oc.add_job_first && !oc.add_break_first) {
       // Infeasible insertion.
@@ -1227,13 +1239,26 @@ void TWRoute::replace(const Input& input,
                                    ? j.services[v_type]
                                    : j.setups[v_type] + j.services[v_type];
 
-    auto oc = order_choice(input,
-                           *current_job,
-                           job_action_time,
-                           b,
-                           current,
-                           next,
-                           current_load);
+    // Use next info after insertion range for ordering decision,
+    // except if there are still jobs to insert after j, in which case
+    // we might have tighter constraints.
+    auto tighter_next = next;
+    if (current_job + 1 < last_job) {
+      const auto& next_j = input.jobs[*(current_job + 1)];
+
+      assert(next.travel <= next.latest);
+      tighter_next.latest =
+        std::min(next.latest - next.travel, next_j.tws.back().end);
+      tighter_next.travel = v.duration(j.index(), next_j.index());
+    }
+
+    const auto oc = order_choice(input,
+                                 *current_job,
+                                 job_action_time,
+                                 b,
+                                 current,
+                                 tighter_next,
+                                 current_load);
 
     assert(oc.add_job_first xor oc.add_break_first);
     if (oc.add_break_first) {