Update machine sepa

Author: Opt-Mucca

highs/mip/HighsMachineSchedSeparator.cpp

@@ -10,7 +10,8 @@
 
 #include "mip/HighsMachineSchedSeparator.h"
 
-#include "../extern/pdqsort/pdqsort.h"
+#include <unordered_map>
+
 #include "mip/HighsCutGeneration.h"
 #include "mip/HighsLpRelaxation.h"
 #include "mip/HighsMipSolverData.h"
@@ -137,6 +138,7 @@ bool HighsMachineSchedSeparator::findSingleMachineScheduleClique(
     if (numRows > maxRows) break;
   }
 
+  // A clique of size 3 needs at least 6 arcs
   if (numRows <= 5) return false;
 
   // Greedily search neighbours of largest degree column for a double-sided
@@ -149,24 +151,19 @@ bool HighsMachineSchedSeparator::findSingleMachineScheduleClique(
       potentialNeighbours.emplace_back(std::get<0>(arc.first));
     }
   }
-  inds.reserve(std::min(largestDegree, 50));
-  inds.emplace_back();
-  inds.back().reserve(std::min(largestDegree, 50));
-  rhss.resize(largestDegree + 1, 0);
   std::vector<HighsInt> neighbours;
   neighbours.reserve(largestDegree + 1);
   neighbours.emplace_back(largestDegreeCol);
   releasedate = mipsolver.mipdata_->domain.col_lower_[largestDegreeCol];
   std::vector<double> processingTimes;
   processingTimes.resize(largestDegree + 1, kHighsInf);
-  // Iterate over potential neighbours, check validity, and build inequalities
+  // Iterate over potential neighbours and check validity
   for (HighsInt col : potentialNeighbours) {
     bool valid_neighbour = true;
     for (HighsInt neighbour : neighbours) {
       auto fromArc = adjacency.find({col, neighbour});
       auto toArc = adjacency.find({neighbour, col});
-      // Need to actually verify that the to and fromArc are opposites (or
-      // can't exist together)
+      // Need to verify that the to and fromArc exist and are opposites
       if (toArc == adjacency.end() || fromArc == adjacency.end() ||
           std::get<1>(fromArc->second) != std::get<1>(toArc->second) ||
           std::get<2>(fromArc->second) == std::get<2>(toArc->second)) {
@@ -176,46 +173,44 @@ bool HighsMachineSchedSeparator::findSingleMachineScheduleClique(
     }
     if (!valid_neighbour) continue;
     size_t newNeighbourIndex = neighbours.size();
-    inds.emplace_back();
-    inds.back().reserve(std::min(largestDegree, 50));
+    // Extract the processing times from the arcs
     for (size_t i = 0; i != neighbours.size(); ++i) {
       HighsInt neighbour = neighbours[i];
       const auto fromArc = adjacency.find({col, neighbour});
       const auto toArc = adjacency.find({neighbour, col});
-      inds[i].emplace_back(std::get<1>(toArc->second));
       processingTimes[newNeighbourIndex] = std::min(
-          processingTimes[newNeighbourIndex], std::get<0>(toArc->second));
-      inds[newNeighbourIndex].emplace_back(std::get<1>(fromArc->second));
+          processingTimes[newNeighbourIndex], std::get<0>(fromArc->second));
       processingTimes[i] =
-          std::min(processingTimes[i], std::get<0>(fromArc->second));
+          std::min(processingTimes[i], std::get<0>(toArc->second));
     }
     releasedate =
         std::min(mipsolver.mipdata_->domain.col_lower_[col], releasedate);
     neighbours.emplace_back(col);
   }
-  if (neighbours.size() <= 3) return false;
+  if (neighbours.size() < 3) return false;
 
-  // Now populate the actual cut coefficients
-  // Currently we only have the cut indices (processing times, i.e.,
-  // coefficients, were not available before this point)
-  vals.resize(neighbours.size());
+  // Now populate the actual inequalities
+  vals.resize(neighbours.size(), std::vector<double>(neighbours.size()));
+  inds.resize(neighbours.size(), std::vector<HighsInt>(neighbours.size()));
+  rhss.resize(neighbours.size());
   for (size_t i = 0; i != neighbours.size(); ++i) {
     rhss[i] -= releasedate;
     HighsInt col = neighbours[i];
-    vals[i].resize(inds[i].size() + 1);
-    for (size_t j = 0; j != inds[i].size(); ++j) {
+    for (size_t j = 0; j != neighbours.size(); ++j) {
       size_t jj = j >= i ? j + 1 : j;
+      if (jj >= neighbours.size()) continue;
       HighsInt neighbour = neighbours[jj];
-      const auto arc = adjacency.find({neighbour, col});
-      assert (arc != adjacency.end());
+      const auto toArc = adjacency.find({neighbour, col});
+      assert(toArc != adjacency.end());
+      inds[i][j] = std::get<1>(toArc->second);
       vals[i][j] = processingTimes[jj];
-      if (std::get<2>(arc->second) == ArcType::kIfBinZero) {
+      if (std::get<2>(toArc->second) == ArcType::kIfBinZero) {
         rhss[i] -= vals[i][j];
         vals[i][j] *= -1;
       }
     }
     // Put the job start time on the LHS
-    inds[i].emplace_back(neighbours[i]);
+    inds[i].back() = col;
     vals[i].back() = -1;
   }
 
@@ -232,7 +227,7 @@ void HighsMachineSchedSeparator::separateLpSolution(
   std::vector<double> rhss;
   double releasedate;
   has_single_machine_schedule =
-        findSingleMachineScheduleClique(vals, inds, rhss, releasedate, mip);
+      findSingleMachineScheduleClique(vals, inds, rhss, releasedate, mip);
   if (!has_single_machine_schedule) {
     separated = true;
     return;
@@ -246,7 +241,8 @@ void HighsMachineSchedSeparator::separateLpSolution(
       viol += lpSolution[inds[i][j]] * vals[i][j];
     }
     if (viol >= 10 * mip.mipdata_->feastol)
-      cutpool.addCut(mip, inds[i].data(), vals[i].data(), inds[i].size(), rhss[i]);
+      cutpool.addCut(mip, inds[i].data(), vals[i].data(), inds[i].size(),
+                     rhss[i]);
   }
   separated = true;
 }

highs/mip/HighsMachineSchedSeparator.h

@@ -24,8 +24,6 @@
 #ifndef MIP_HIGHS_MACHINE_SCHED_SEPARATOR_H_
 #define MIP_HIGHS_MACHINE_SCHED_SEPARATOR_H_
 
-#include <unordered_map>
-
 #include "mip/HighsMipSolver.h"
 #include "mip/HighsMipSolverData.h"
 #include "mip/HighsSeparator.h"