Switch to differential implementation

commit 45d4c06ef9efc4a6e0dd5e80d7c41c93b6b26b1e
Merge: d86f2420 347b33a
Author: Florian Fontan <[email protected]>
Date:   Sat Jun 20 23:36:01 2020 +0200

    Merge branch 'dev' into differential

commit d86f24202e4f09f6e387a70d66b2634e1643138f
Author: Florian Fontan <[email protected]>
Date:   Thu May 14 21:04:14 2020 +0200

    Implement differential branching scheme

Author: fontanf

packingsolver/algorithms/a_star.hpp

@@ -51,8 +51,8 @@ void AStar<Solution, BranchingScheme>::run()
 
     // Initialize queue
     auto comp = branching_scheme_.compare(guide_id_);
-    std::multiset<Node, decltype(comp)> q(comp);
-    q.insert(Node(branching_scheme_));
+    std::multiset<std::shared_ptr<const Node>, decltype(comp)> q(comp);
+    q.insert(branching_scheme_.root());
 
     while (!q.empty()) {
         node_number_++;
@@ -65,38 +65,37 @@ void AStar<Solution, BranchingScheme>::run()
         }
 
         // Get node from the queue
-        Node node_cur(*q.begin());
+        auto node_cur = *q.begin();
         q.erase(q.begin());
-        LOG_FOLD(info_, "node_cur" << std::endl << node_cur);
+        LOG_FOLD(info_, "node_cur" << std::endl << *node_cur);
 
         // Bound
-        if (node_cur.bound(sol_best_)) {
+        if (node_cur->bound(sol_best_)) {
             LOG(info_, " bound ×" << std::endl);
             continue;
         }
 
-        for (const Insertion& insertion: node_cur.children(info_)) {
+        for (const Insertion& insertion: branching_scheme_.children(node_cur, info_)) {
             LOG(info_, insertion << std::endl);
-            Node node_tmp(node_cur);
-            node_tmp.apply_insertion(insertion, info_);
+            auto child = branching_scheme_.child(node_cur, insertion);
             //LOG_FOLD(info_, "node_tmp" << std::endl << node_tmp);
 
             // Bound
-            if (node_tmp.bound(sol_best_)) {
+            if (child->bound(sol_best_)) {
                 LOG(info_, " bound ×" << std::endl);
                 continue;
             }
 
             // Update best solution
-            if (sol_best_ < node_tmp) {
+            if (sol_best_ < *child) {
                 std::stringstream ss;
                 ss << "A* (thread " << thread_id_ << ")";
-                sol_best_.update(node_tmp.convert(sol_best_), ss, info_);
+                sol_best_.update(child->convert(sol_best_), ss, info_);
             }
 
             // Add child to the queue
-            if (!node_tmp.full())
-                q.insert(node_tmp);
+            if (!child->full())
+                q.insert(child);
         }
 
         LOG_FOLD_END(info_, "");

packingsolver/algorithms/depth_first_search.hpp

@@ -33,20 +33,20 @@ class DepthFirstSearch
     GuideId guide_id_ = 0;
     Info info_ = Info();
 
-    void rec(const typename BranchingScheme::Node& node_cur);
+    void rec(const std::shared_ptr<const typename BranchingScheme::Node>& node_cur);
 
 };
 
 /************************** Template implementation ***************************/
 
 template <typename Solution, typename BranchingScheme>
-void DepthFirstSearch<Solution, BranchingScheme>::rec(const typename BranchingScheme::Node& node_cur)
+void DepthFirstSearch<Solution, BranchingScheme>::rec(const std::shared_ptr<const typename BranchingScheme::Node>& node_cur)
 {
     typedef typename BranchingScheme::Node Node;
     typedef typename BranchingScheme::Insertion Insertion;
 
     LOG_FOLD_START(info_, "rec" << std::endl);
-    LOG_FOLD(info_, "node_cur" << std::endl << node_cur);
+    LOG_FOLD(info_, "node_cur" << std::endl << *node_cur);
 
     // Check time
     if (!info_.check_time()) {
@@ -55,40 +55,39 @@ void DepthFirstSearch<Solution, BranchingScheme>::rec(const typename BranchingSc
     }
 
     // Bound
-    if (node_cur.bound(sol_best_)) {
+    if (node_cur->bound(sol_best_)) {
         LOG(info_, " bound ×" << std::endl);
         return;
     }
 
-    std::vector<Node> children;
-    for (const Insertion& insertion: node_cur.children(info_)) {
+    std::vector<std::shared_ptr<const Node>> children;
+    for (const Insertion& insertion: branching_scheme_.children(node_cur, info_)) {
         LOG(info_, insertion << std::endl);
-        Node node_tmp(node_cur);
-        node_tmp.apply_insertion(insertion, info_);
-        LOG_FOLD(info_, "node_tmp" << std::endl << node_tmp);
+        auto child = branching_scheme_.child(node_cur, insertion);
+        LOG_FOLD(info_, "child" << std::endl << *child);
 
         // Bound
-        if (node_tmp.bound(sol_best_)) {
+        if (child->bound(sol_best_)) {
             LOG(info_, " bound ×" << std::endl);
             continue;
         }
 
         // Update best solution
-        if (sol_best_ < node_tmp) {
+        if (sol_best_ < *child) {
             std::stringstream ss;
             ss << "A* (thread " << thread_id_ << ")";
-            sol_best_.update(node_tmp.convert(sol_best_), ss, info_);
+            sol_best_.update(child->convert(sol_best_), ss, info_);
         }
 
         // Add child to the queue
-        if (!node_tmp.full())
-            children.push_back(node_tmp);
+        if (!child->full())
+            children.push_back(child);
     }
 
     auto comp = branching_scheme_.compare(guide_id_);
     sort(children.begin(), children.end(), comp);
 
-    for (const Node& child: children)
+    for (const auto& child: children)
         rec(child);
 
     LOG_FOLD_END(info_, "");
@@ -99,8 +98,8 @@ void DepthFirstSearch<Solution, BranchingScheme>::run()
 {
     typedef typename BranchingScheme::Node Node;
 
-    Node node(branching_scheme_);
-    rec(node);
+    std::shared_ptr<const Node> root = branching_scheme_.root();
+    rec(root);
 }
 
 }