bestSum - tabulation & vector of pointers (C++)

Author: Dhruvvvx17

Dynamic Programming/C++/bestSum_tab.cpp

@@ -0,0 +1,88 @@
+// given a target an an array of non-negative integers, return the smallest combination of values that sum up to the target value.
+// the numbers can be used repeatedly. If no combination possible return NULL
+
+#include<iostream>
+#include<vector>
+using namespace std;
+
+vector<int>* createVector() {
+    vector<int> *new_v = new vector<int>();
+    return new_v;
+}
+
+// create a new vector and copies the values from the vector passed as parameter
+vector<int>* createVector(vector<int> prev){
+    vector<int> *new_v = new vector<int>();
+
+    for(int x: prev){
+        new_v->push_back(x);
+    }
+    return new_v;
+}
+
+// compare two vectors to see which is the shorter one
+void compareAndProceed(vector<int> *potentialRes, vector<int> *originalRes, int ele){
+    return;
+}
+
+vector<int>* bestSum_tab(int target, vector<int> arr) {
+    // init a vector of vectors where each subvector is initially nullptr
+    vector<vector<int>*> table(target+1, nullptr);
+
+    table[0] = createVector();
+
+    for(int i=0; i<table.size(); i++){
+        // continue only for valid/true positions
+        if(table[i] != nullptr){
+            // iterate over all possible shifts (i.e., arr values)
+            for(int j=0; j<arr.size(); j++) {
+
+                // check for out of bounds
+                if(i + arr[j] < table.size()){
+                    // compare the length between the result at new position (if any) and the potential result in this iteration
+                    // null -> no comparison simply copy, else compare size and copy if potential result is shorter
+                    if(table[i + arr[j]] == nullptr 
+                        || table[i + arr[j]]->size() > table[i]->size())
+                    {
+                        table[i + arr[j]] = createVector(*table[i]);
+                        table[i + arr[j]]->push_back(arr[j]);
+                    }
+                }                
+            }
+        }
+    }
+    return table[target];
+}
+
+
+int main() {
+
+    int n, iter = 1, temp, target;
+    cout<<"Enter number of elements in array: ";
+    cin>>n;
+
+    vector<int> arr;
+    while(iter <= n) {
+        cout<<"Enter element "<<iter<<": ";
+        cin>>temp;
+        arr.push_back(temp);
+        ++iter;
+    }
+    
+    cout<<"Enter target: ";
+    cin>>target;
+
+    vector<int> *bestRes = bestSum_tab(target, arr);
+
+    if(bestRes == nullptr)
+        cout<<target<<" cannot be generated from array"<<endl;
+    else {
+        cout<<target<<" can be generated from array elements: ";
+        for(int num : *bestRes){
+            cout<<num<<" ";
+        }
+        cout<<endl;
+    }
+
+    return 0;
+}

Dynamic Programming/C++/howSum_tab.cpp

@@ -27,7 +27,7 @@ vector<int>* createVector(vector<int> prev){
 }
 
 vector<int>* howSum_tab(int target, vector<int> arr) {
-    // init a vector of vectors where each subvector has -1
+    // init a vector of vectors where each subvector is initially nullptr
     vector<vector<int>*> table(target+1, nullptr);
 
     // set the first element of the table to an empty vector

Dynamic Programming/Python/bestSum_tab.py

@@ -0,0 +1,39 @@
+# given a target an an array of non-negative integers, return the smallest combination of values that sum up to the target value.
+# the numbers can be used repeatedly. If no combination possible return NULL
+
+def bestSum_tab(target, arr):
+
+    table = [None for _ in range(target+1)]
+
+    # possible to generate 0 by not using any number from arr
+    table[0] = []
+
+    for i in range(len(table)):
+        # check for valid positions
+        if not(table[i] == None):
+            for j in range(len(arr)):
+                # check for out of bounds
+                if(i + arr[j] < len(table)):
+                    # if new position is None or if new position has a longer result - copy the original (table[i])
+                    if(table[i + arr[j]] == None or len(table[i + arr[j]]) > len(table[i])):
+                        table[i + arr[j]] = table[i][:]
+                        table[i + arr[j]].append(arr[j])
+    
+    return table[target]
+
+if __name__ == "__main__":
+    n = int(input("Enter number of elements: "))
+    i = 0
+    arr = []
+    while(i<n):
+        t = int(input(f"Enter element {i}: "))
+        arr.append(t)
+        i += 1
+    
+    target = int(input("Enter target: "))
+
+    res = bestSum_tab(target, arr)
+    if(res):
+        print(f"{target} can be generated from array elements {res}")
+    else:
+        print(f"{target} cannot be generated from array")