KargerMinCutTimeout: recorded discovery_time iteration

Author: jkomyno

KargerMinCutTimeout/karger_timeout.h

@@ -1,9 +1,10 @@
 #pragma once
 
+#include <any>       // std::any
+#include <array>     // std::array
 #include <iostream>  // std::cout, std::endl
 #include <limits>    // std::numeric_limits
 #include <memory>    // std::shared_ptr, std::unique_ptr, std::make_unique
-#include <utility>   // std::make_pair
 
 #include "AdjacencyMapGraph.h"
 #include "full_contraction.h"
@@ -12,19 +13,22 @@
 
 /**
  * Run Karger's randomized min-cut algorithm k times on the given graph.
- * Return the a pair containing the min-cut found and the discovery time.
+ * Return the an array containing the min-cut found, the discovery time and the discovery iteration.
  * Time: O(n^4 * log(n))
  * Space: O(n + m)
  */
-[[nodiscard]] auto karger(timeout::timeout_signal&& signal,
-                          const std::shared_ptr<AdjacencyMapGraph>& graph, size_t k,
-                          const stopwatch::time_point_t program_time_start) noexcept {
+[[nodiscard]] std::array<std::any, 3> karger(
+    timeout::timeout_signal&& signal, const std::shared_ptr<AdjacencyMapGraph>& graph, size_t k,
+    const stopwatch::time_point_t program_time_start) noexcept {
     // keep track of the min-cut discovery time
     stopwatch::time_point_t discovery_time_stop;
 
     // keeps track of the minimum cut
     size_t min_cut = std::numeric_limits<size_t>::max();
 
+    // keeps track of the iteration of the minimum cut
+    size_t discovery_iteration = 0;
+
     bool keep_going = true;
 
     // execute full_contraction k times to hopefully find the minimum cut.
@@ -37,8 +41,10 @@
         const size_t cut = contracted_graph->edge_size();
 
         if (cut < min_cut) {
-            // a better cut has been found, so we update min_cut and reset stop_discovery_time
+            // a better cut has been found, so we update min_cut, discovery_iteration and reset
+            // stop_discovery_time
             min_cut = cut;
+            discovery_iteration = i;
             discovery_time_stop = stopwatch::now();
         }
 
@@ -54,6 +60,6 @@
 
     // std::make_tuple doesn't work, that's probably related to the fact that std::tuple<...>
     // doesn't have a default constructor but std::packaged_task (used in timeout.h) needs a default
-    // constructor.
-    return std::make_pair(min_cut, discovery_time);
+    // constructor. Using std::array<std::any, 3> is just an escamotage.
+    return {min_cut, discovery_time, discovery_iteration + 1};
 }

KargerMinCutTimeout/main.cpp

@@ -1,3 +1,4 @@
+#include <any>
 #include <iostream>  // std::cout, std::endl
 #include <string>    // std::string_literals
 
@@ -33,11 +34,11 @@ int main(int argc, char** argv) {
     // the timeout is set to 2 minutes
     auto timeout_min = 2min;
 
-    const auto [karger_result, karger_duration] =
+    const auto [result, karger_duration] =
         timeout::with_timeout(std::move(timeout_min), stopwatch::decorator<stopwatch::us_t>(karger),
                               std::ref(graph), k, program_time_start);
 
-    const auto& [min_cut, discovery_time] = karger_result;
+    const auto& [min_cut, discovery_time, discovery_iteration] = result;
 
     // stop the stopwatch
     auto program_time_stop = stopwatch::now();
@@ -46,7 +47,10 @@ int main(int argc, char** argv) {
     const auto program_time =
         stopwatch::duration<stopwatch::us_t>(program_time_start, program_time_stop);
 
-    std::cout << "min_cut: "s << min_cut << std::endl;
+    std::cout << "min_cut: "s << std::any_cast<size_t>(min_cut) << std::endl;
     std::cout << "program_time: "s << program_time << std::endl;
-    std::cout << "discovery_time: "s << discovery_time << std::endl;
+    std::cout << "discovery_time: "s << std::any_cast<decltype(program_time)>(discovery_time)
+              << std::endl;
+    std::cout << "discovery_iteration: "s << std::any_cast<size_t>(discovery_iteration)
+              << std::endl;
 }