diff --git a/include/knapsacksolver/knapsack/algorithms/dynamic_programming_bellman.hpp b/include/knapsacksolver/knapsack/algorithms/dynamic_programming_bellman.hpp
index d3d5299e..c15e7fc8 100644
--- a/include/knapsacksolver/knapsack/algorithms/dynamic_programming_bellman.hpp
+++ b/include/knapsacksolver/knapsack/algorithms/dynamic_programming_bellman.hpp
@@ -7,22 +7,22 @@ namespace knapsacksolver
 namespace knapsack
 {
 
-const Output dynamic_programming_bellman_rec(
+Output dynamic_programming_bellman_rec(
         const Instance& instance,
         const Parameters& parameters = {});
 
 
-const Output dynamic_programming_bellman_array(
+Output dynamic_programming_bellman_array(
         const Instance& instance,
         const Parameters& parameters = {});
 
 
-const Output dynamic_programming_bellman_array_parallel(
+Output dynamic_programming_bellman_array_parallel(
         const Instance& instance,
         const Parameters& parameters = {});
 
 
-const Output dynamic_programming_bellman_array_all(
+Output dynamic_programming_bellman_array_all(
         const Instance& instance,
         const Parameters& parameters = {});
 
@@ -121,7 +121,7 @@ const DynamicProgrammingBellmanArrayPartOutput dynamic_programming_bellman_array
         const DynamicProgrammingBellmanArrayPartParameters& parameters = {});
 
 
-const Output dynamic_programming_bellman_array_rec(
+Output dynamic_programming_bellman_array_rec(
         const Instance& instance,
         const Parameters& parameters = {});
 
@@ -152,7 +152,7 @@ struct DynamicProgrammingBellmanListParameters: Parameters
     }
 };
 
-const Output dynamic_programming_bellman_list(
+Output dynamic_programming_bellman_list(
         const Instance& instance,
         const DynamicProgrammingBellmanListParameters& parameters = {});
 
diff --git a/include/knapsacksolver/knapsack/algorithms/greedy.hpp b/include/knapsacksolver/knapsack/algorithms/greedy.hpp
index df7f6fa4..f952b58e 100644
--- a/include/knapsacksolver/knapsack/algorithms/greedy.hpp
+++ b/include/knapsacksolver/knapsack/algorithms/greedy.hpp
@@ -8,7 +8,7 @@ namespace knapsacksolver
 namespace knapsack
 {
 
-const Output trivial(
+Output trivial(
         const Instance& instance,
         const Parameters& parameters = {});
 
@@ -44,7 +44,7 @@ struct GreedyParameters: Parameters
     }
 };
 
-const Output greedy(
+Output greedy(
         const Instance& instance,
         const GreedyParameters& parameters = {});
 
diff --git a/include/knapsacksolver/knapsack/algorithms/surrogate_relaxation.hpp b/include/knapsacksolver/knapsack/algorithms/surrogate_relaxation.hpp
index 22b76308..0996c788 100644
--- a/include/knapsacksolver/knapsack/algorithms/surrogate_relaxation.hpp
+++ b/include/knapsacksolver/knapsack/algorithms/surrogate_relaxation.hpp
@@ -14,7 +14,7 @@ struct SurrogateRelaxationParameters: Parameters
     SolveCallback solve_callback = [](const Instance& instance) { return Output(instance); };
 };
 
-const Output surrogate_relaxation(
+Output surrogate_relaxation(
         const Instance& instance,
         const SurrogateRelaxationParameters& parameters = {});
 
diff --git a/include/knapsacksolver/knapsack/algorithms/upper_bound_dantzig.hpp b/include/knapsacksolver/knapsack/algorithms/upper_bound_dantzig.hpp
index 77ab5857..4326f747 100644
--- a/include/knapsacksolver/knapsack/algorithms/upper_bound_dantzig.hpp
+++ b/include/knapsacksolver/knapsack/algorithms/upper_bound_dantzig.hpp
@@ -39,7 +39,7 @@ struct UpperBoundDantzigParameters: Parameters
     }
 };
 
-const Output upper_bound_dantzig(
+Output upper_bound_dantzig(
         const Instance& instance,
         const UpperBoundDantzigParameters& parameters = {});
 
diff --git a/include/knapsacksolver/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.hpp b/include/knapsacksolver/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.hpp
index fd9cbbbc..468e6d0d 100644
--- a/include/knapsacksolver/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.hpp
+++ b/include/knapsacksolver/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.hpp
@@ -7,15 +7,15 @@ namespace knapsacksolver
 namespace multiple_choice_subset_sum
 {
 
-const Output dynamic_programming_bellman_array(
+Output dynamic_programming_bellman_array(
         const Instance& instance,
         const Parameters& parameters = {});
 
-const Output dynamic_programming_bellman_word_ram(
+Output dynamic_programming_bellman_word_ram(
         const Instance& instance,
         const Parameters& parameters = {});
 
-const Output dynamic_programming_bellman_word_ram_rec(
+Output dynamic_programming_bellman_word_ram_rec(
         const Instance& instance,
         const Parameters& parameters = {});
 
diff --git a/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_balancing.hpp b/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_balancing.hpp
index 91489e95..d8a13146 100644
--- a/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_balancing.hpp
+++ b/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_balancing.hpp
@@ -7,7 +7,7 @@ namespace knapsacksolver
 namespace subset_sum
 {
 
-const Output dynamic_programming_balancing_array(
+Output dynamic_programming_balancing_array(
         const Instance& instance,
         const Parameters& parameters = {});
 
diff --git a/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_bellman.hpp b/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_bellman.hpp
index 393b7975..7f02def6 100644
--- a/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_bellman.hpp
+++ b/include/knapsacksolver/subset_sum/algorithms/dynamic_programming_bellman.hpp
@@ -7,22 +7,53 @@ namespace knapsacksolver
 namespace subset_sum
 {
 
-const Output dynamic_programming_bellman_array(
+struct DynamicProgrammingBellmanArrayOutput: public Output
+{
+    /** Constructor. */
+    DynamicProgrammingBellmanArrayOutput(const Instance& instance):
+        Output(instance)
+    { }
+
+    std::vector<ItemId> values;
+
+    bool is_reachable(Weight weight) const
+    {
+        return values[weight] != -1;
+    }
+};
+
+DynamicProgrammingBellmanArrayOutput dynamic_programming_bellman_array(
         const Instance& instance,
         const Parameters& parameters = {});
 
-const Output dynamic_programming_bellman_list(
+Output dynamic_programming_bellman_list(
         const Instance& instance,
         const Parameters& parameters = {});
 
-const Output dynamic_programming_bellman_word_ram(
+struct DynamicProgrammingBellmanWordRamOutput: public Output
+{
+    /** Constructor. */
+    DynamicProgrammingBellmanWordRamOutput(const Instance& instance):
+        Output(instance)
+    { }
+
+    std::vector<uint64_t> values;
+
+    bool is_reachable(Weight weight) const
+    {
+        Weight word = weight / 64;
+        int bit = weight % 64;
+        return (values[word] >> bit);
+    }
+};
+
+DynamicProgrammingBellmanWordRamOutput dynamic_programming_bellman_word_ram(
         const Instance& instance,
         const Parameters& parameters = {});
 
-const Output dynamic_programming_bellman_word_ram_rec(
+Output dynamic_programming_bellman_word_ram_rec(
         const Instance& instance,
         const Parameters& parameters = {});
 
 }
 }
-
diff --git a/src/knapsack/algorithms/dynamic_programming_bellman.cpp b/src/knapsack/algorithms/dynamic_programming_bellman.cpp
index 5533d6de..7d284e5d 100644
--- a/src/knapsack/algorithms/dynamic_programming_bellman.cpp
+++ b/src/knapsack/algorithms/dynamic_programming_bellman.cpp
@@ -16,7 +16,7 @@ using namespace knapsacksolver::knapsack;
 ////////////////////// dynamic_programming_bellman_array ///////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::knapsack::dynamic_programming_bellman_array(
+Output knapsacksolver::knapsack::dynamic_programming_bellman_array(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -93,7 +93,7 @@ void dynamic_programming_bellman_array_parallel_worker(
     }
 }
 
-const Output knapsacksolver::knapsack::dynamic_programming_bellman_array_parallel(
+Output knapsacksolver::knapsack::dynamic_programming_bellman_array_parallel(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -222,7 +222,7 @@ Profit dynamic_programming_bellman_rec_rec(
     return values[state_id];
 }
 
-const Output knapsacksolver::knapsack::dynamic_programming_bellman_rec(
+Output knapsacksolver::knapsack::dynamic_programming_bellman_rec(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -281,7 +281,7 @@ const Output knapsacksolver::knapsack::dynamic_programming_bellman_rec(
 //////////////////// dynamic_programming_bellman_array_all /////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::knapsack::dynamic_programming_bellman_array_all(
+Output knapsacksolver::knapsack::dynamic_programming_bellman_array_all(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -727,7 +727,7 @@ void dynamic_programming_bellman_array_rec_rec(
     }
 }
 
-const Output knapsacksolver::knapsack::dynamic_programming_bellman_array_rec(
+Output knapsacksolver::knapsack::dynamic_programming_bellman_array_rec(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -804,7 +804,7 @@ std::ostream& operator<<(std::ostream& os, const std::vector<BellmanState>& l)
     return os;
 }
 
-const Output knapsacksolver::knapsack::dynamic_programming_bellman_list(
+Output knapsacksolver::knapsack::dynamic_programming_bellman_list(
         const Instance& instance,
         const DynamicProgrammingBellmanListParameters& parameters)
 {
diff --git a/src/knapsack/algorithms/greedy.cpp b/src/knapsack/algorithms/greedy.cpp
index c23ddaf5..7012d486 100644
--- a/src/knapsack/algorithms/greedy.cpp
+++ b/src/knapsack/algorithms/greedy.cpp
@@ -5,7 +5,7 @@
 
 using namespace knapsacksolver::knapsack;
 
-const Output knapsacksolver::knapsack::greedy(
+Output knapsacksolver::knapsack::greedy(
         const Instance& instance,
         const GreedyParameters& parameters)
 {
diff --git a/src/knapsack/algorithms/surrogate_relaxation.cpp b/src/knapsack/algorithms/surrogate_relaxation.cpp
index 1bf22cd7..cce990f2 100644
--- a/src/knapsack/algorithms/surrogate_relaxation.cpp
+++ b/src/knapsack/algorithms/surrogate_relaxation.cpp
@@ -212,7 +212,7 @@ UBS surrogate_solve(
     return {ub, s_best};
 }
 
-const Output knapsacksolver::knapsack::surrogate_relaxation(
+Output knapsacksolver::knapsack::surrogate_relaxation(
         const Instance& instance,
         const SurrogateRelaxationParameters& parameters)
 {
diff --git a/src/knapsack/algorithms/upper_bound_dantzig.cpp b/src/knapsack/algorithms/upper_bound_dantzig.cpp
index 4fc1c593..81616536 100644
--- a/src/knapsack/algorithms/upper_bound_dantzig.cpp
+++ b/src/knapsack/algorithms/upper_bound_dantzig.cpp
@@ -5,7 +5,7 @@
 
 using namespace knapsacksolver::knapsack;
 
-const Output knapsacksolver::knapsack::upper_bound_dantzig(
+Output knapsacksolver::knapsack::upper_bound_dantzig(
         const Instance& instance,
         const UpperBoundDantzigParameters& parameters)
 {
diff --git a/src/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.cpp b/src/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.cpp
index 4e931362..8847802b 100644
--- a/src/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.cpp
+++ b/src/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.cpp
@@ -10,7 +10,7 @@ using namespace knapsacksolver::multiple_choice_subset_sum;
 ////////////////////// dynamic_programming_bellman_array ///////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bellman_array(
+Output knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bellman_array(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -98,7 +98,7 @@ const Output knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bel
 ///////////////////// dynamic_programming_bellman_word_ram /////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bellman_word_ram(
+Output knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bellman_word_ram(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -377,7 +377,7 @@ void dynamic_programming_bellman_word_ram_rec_rec(
     }
 }
 
-const Output knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bellman_word_ram_rec(
+Output knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bellman_word_ram_rec(
         const Instance& instance,
         const Parameters& parameters)
 {
diff --git a/src/subset_sum/algorithms/dynamic_programming_balancing.cpp b/src/subset_sum/algorithms/dynamic_programming_balancing.cpp
index 5566fd1d..7b9e59df 100644
--- a/src/subset_sum/algorithms/dynamic_programming_balancing.cpp
+++ b/src/subset_sum/algorithms/dynamic_programming_balancing.cpp
@@ -8,7 +8,7 @@ using namespace knapsacksolver::subset_sum;
 ///////////////////// dynamic_programming_balancing_array //////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::subset_sum::dynamic_programming_balancing_array(
+Output knapsacksolver::subset_sum::dynamic_programming_balancing_array(
         const Instance& instance,
         const Parameters& parameters)
 {
diff --git a/src/subset_sum/algorithms/dynamic_programming_bellman.cpp b/src/subset_sum/algorithms/dynamic_programming_bellman.cpp
index 3f5ae450..d727490d 100644
--- a/src/subset_sum/algorithms/dynamic_programming_bellman.cpp
+++ b/src/subset_sum/algorithms/dynamic_programming_bellman.cpp
@@ -8,17 +8,17 @@ using namespace knapsacksolver::subset_sum;
 ////////////////////// dynamic_programming_bellman_array ///////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::subset_sum::dynamic_programming_bellman_array(
+DynamicProgrammingBellmanArrayOutput knapsacksolver::subset_sum::dynamic_programming_bellman_array(
         const Instance& instance,
         const Parameters& parameters)
 {
-    Output output(instance);
+    DynamicProgrammingBellmanArrayOutput output(instance);
     AlgorithmFormatter algorithm_formatter(parameters, output);
     algorithm_formatter.start("Dynamic programming - Bellman - array");
     algorithm_formatter.print_header();
 
-    std::vector<ItemId> values(instance.capacity() + 1, -1);
-    values[0] = -2;
+    output.values = std::vector<ItemId>(instance.capacity() + 1, -1);
+    output.values[0] = -2;
     Weight weight_sum = 0;
     for (ItemPos item_id = 0; item_id < instance.number_of_items(); ++item_id) {
         // Check time
@@ -32,9 +32,9 @@ const Output knapsacksolver::subset_sum::dynamic_programming_bellman_array(
         for (Weight weight = std::min(instance.capacity(), weight_sum);
                 weight >= instance.weight(item_id);
                 weight--) {
-            if (values[weight] == -1
-                    && values[weight - instance.weight(item_id)] != -1) {
-                values[weight] = item_id;
+            if (output.values[weight] == -1
+                    && output.values[weight - instance.weight(item_id)] != -1) {
+                output.values[weight] = item_id;
             }
         }
 
@@ -43,20 +43,20 @@ const Output knapsacksolver::subset_sum::dynamic_programming_bellman_array(
         //std::cout << std::endl;
 
         // If optimum reached, stop.
-        if (values[instance.capacity()] != -1)
+        if (output.values[instance.capacity()] != -1)
             break;
     }
 
     Solution solution(instance);
     Weight weight_cur = 0;
     for (Weight weight = instance.capacity(); weight >= 0; weight--) {
-        if (values[weight] != -1) {
+        if (output.values[weight] != -1) {
             weight_cur = weight;
             break;
         }
     }
     while (weight_cur > 0) {
-        ItemId item_id = values[weight_cur];
+        ItemId item_id = output.values[weight_cur];
         solution.add(item_id);
         weight_cur -= instance.weight(item_id);
     }
@@ -78,7 +78,7 @@ const Output knapsacksolver::subset_sum::dynamic_programming_bellman_array(
 /////////////////////// dynamic_programming_bellman_list ///////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::subset_sum::dynamic_programming_bellman_list(
+Output knapsacksolver::subset_sum::dynamic_programming_bellman_list(
         const Instance& instance,
         const Parameters& parameters)
 {
@@ -140,19 +140,19 @@ const Output knapsacksolver::subset_sum::dynamic_programming_bellman_list(
 ///////////////////// dynamic_programming_bellman_word_ram /////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-const Output knapsacksolver::subset_sum::dynamic_programming_bellman_word_ram(
+DynamicProgrammingBellmanWordRamOutput knapsacksolver::subset_sum::dynamic_programming_bellman_word_ram(
         const Instance& instance,
         const Parameters& parameters)
 {
-    Output output(instance);
+    DynamicProgrammingBellmanWordRamOutput output(instance);
     AlgorithmFormatter algorithm_formatter(parameters, output);
     algorithm_formatter.start("Dynamic programming - Bellman - word RAM");
     algorithm_formatter.print_header();
 
     Weight capacity_number_of_words = (instance.capacity() >> 6);
     Weight capacity_number_of_bits_to_shift = instance.capacity() - (capacity_number_of_words << 6);
-    std::vector<uint64_t> values(capacity_number_of_words + 1, 0);
-    values[0] = 1;
+    output.values = std::vector<uint64_t>(capacity_number_of_words + 1, 0);
+    output.values[0] = 1;
 
     Weight weight_sum = 0;
 
@@ -173,15 +173,15 @@ const Output knapsacksolver::subset_sum::dynamic_programming_bellman_word_ram(
         Weight word_write = word_read - number_of_words_to_shift;
         if (number_of_bits_to_shift_left != 0) {
             while (word_write > 0) {
-                values[word_read] |= (values[word_write] << number_of_bits_to_shift_left);
-                values[word_read] |= (values[word_write - 1] >> number_of_bits_to_shift_right);
+                output.values[word_read] |= (output.values[word_write] << number_of_bits_to_shift_left);
+                output.values[word_read] |= (output.values[word_write - 1] >> number_of_bits_to_shift_right);
                 word_read--;
                 word_write--;
             }
-            values[word_read] |= (values[word_write] << number_of_bits_to_shift_left);
+            output.values[word_read] |= (output.values[word_write] << number_of_bits_to_shift_left);
         } else {
             while (word_write >= 0) {
-                values[word_read] |= values[word_write];
+                output.values[word_read] |= output.values[word_write];
                 word_read--;
                 word_write--;
             }
@@ -192,18 +192,18 @@ const Output knapsacksolver::subset_sum::dynamic_programming_bellman_word_ram(
         //        std::cout << ((values[word] >> bit) & 1);
         //std::cout << std::endl;
 
-        if (((values[capacity_number_of_words] >> capacity_number_of_bits_to_shift) & 1) == 1)
+        if (((output.values[capacity_number_of_words] >> capacity_number_of_bits_to_shift) & 1) == 1)
             break;
     }
 
     Weight optimal_value = 0;
     for (Weight word = capacity_number_of_words; optimal_value == 0; --word) {
-        if (values[word] == 0)
+        if (output.values[word] == 0)
             continue;
         for (int bit = 63; bit >= 0; --bit) {
             Weight weight = 64 * word + bit;
             if (weight <= instance.capacity()
-                    && ((values[word] >> bit) & 1) == 1) {
+                    && ((output.values[word] >> bit) & 1) == 1) {
                 optimal_value = weight;
                 break;
             }
@@ -381,7 +381,7 @@ void dynamic_programming_bellman_word_ram_rec_rec(
     }
 }
 
-const Output knapsacksolver::subset_sum::dynamic_programming_bellman_word_ram_rec(
+Output knapsacksolver::subset_sum::dynamic_programming_bellman_word_ram_rec(
         const Instance& instance,
         const Parameters& parameters)
 {