fib, gridT, canSum - simple tabulation

Author: Dhruvvvx17

Diff for: Dynamic Programming/C++/canSum_tab.cpp

@@ -0,0 +1,55 @@
+// given a target an an array of non-negative integers, find out if the target can be constructed using the number of the array.
+// the numbers can be used repeatedly.
+// m - target and n = arr.size()
+// Time = O(nm)
+// Space = O(m)
+
+#include<iostream>
+#include<vector>
+using namespace std;
+
+bool canSum_tab(int target, vector<int> arr) {
+    vector<bool> table (target+1, false);
+
+    // it is possible to generate 0 from arr (without picking any element)
+    table[0] = true;
+
+    // single pass of the table
+    for(int i=0; i<table.size(); i++) {
+        if(table[i] == true) {
+            // for a given true element, change curr_pos + arr[j] to true as well
+            for(int j=0; j<arr.size(); j++) {
+                // check for out of bounds
+                if(i + arr[j] < table.size()) {
+                    table[i + arr[j]] = true;
+                }
+            }
+        }
+    }
+
+    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;
+
+    if(canSum_tab(target, arr))
+        cout<<target<<" can be generated from array"<<endl;
+    else
+        cout<<target<<" cannot be generated from array"<<endl;
+
+    return 0;
+}

Diff for: Dynamic Programming/C++/fibonacci_tab.cpp

@@ -0,0 +1,28 @@
+// Given an integer n, find the nth fibonacci number using tabulation method.
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+#include<iostream>
+#include<vector>
+using namespace std;
+
+int64_t fib_tab(int n){
+    vector<int64_t> table (n+1, 0);
+    table[0] = 0;
+    table[1] = 1;
+
+    for(int i=2; i<=n; i++){
+        table[i] = table[i-1] + table[i-2];
+    }
+    return table[n];
+}
+
+int main() {
+    int n;
+    cout<<"Enter n: ";
+    cin>>n;
+
+    cout<<"The "<<n<<"th fibonacci number is: "<<fib_tab(n);
+
+    return 0;
+}

Diff for: Dynamic Programming/C++/gridTraveller_tab.cpp

@@ -0,0 +1,37 @@
+// Given a mxn grid, how many ways can I go from the start (0,0) to the end (m,n) by just moving RIGHT or DOWN
+// Time complexity = O(m*n)
+// Space complexity = O(m*n)
+
+#include<iostream>
+#include<vector>
+#include<map>
+using namespace std;
+
+int64_t gridTraveller_tab(int rows, int cols){
+    vector<vector<int64_t>> table (rows+1, vector<int64_t> (cols + 1, 0));
+
+    // 0th row and 0th col will be populated with zeros
+    // table[1][1] will be 1 as there is 1 way to reach destination on a 1x1 grid
+    table[1][1] = 1;
+
+    for(int i=0; i<=rows; i++){
+        for(int j=0; j<=cols; j++){
+            if(j+1 <= cols) table[i][j+1] += table[i][j];
+            if(i+1 <= rows) table[i+1][j] += table[i][j];
+        }
+    }
+    return table[rows][cols];
+}
+
+int main() {
+
+    int m, n;
+    cout<<"Enter number of rows: ";
+    cin>>m;
+    cout<<"Enter number of cols: ";
+    cin>>n;
+
+    cout<<"Number of ways to travel from (1,1) to ("<<m<<","<<n<<") is: "<<gridTraveller_tab(m,n)<<endl;
+
+    return 0;
+}

Diff for: Dynamic Programming/Python/canSum_tab.py

@@ -0,0 +1,30 @@
+# given a target an an array of non-negative integers, find out if the target can be constructed using the number of the array.
+# the numbers can be used repeatedly.
+
+def canSum_tab(target, arr):
+    table = [False for _ in range(target+1)]
+    table[0] = True
+
+    for i in range(0, target+1):
+        if table[i]:
+            for shift in arr:
+                if i + shift < len(table):
+                    table[i+shift] = True
+
+    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: "))
+
+    if(canSum_tab(target, arr)):
+        print(f"{target} can be generated from array")
+    else:
+        print(f"{target} cannot be generated from array")

Diff for: Dynamic Programming/Python/fibonacci_tab.py

@@ -0,0 +1,19 @@
+# Given an integer n, find the nth fibonacci number using tabulation method
+# Time complexity: O(n)
+# Space complexity: O(n)
+
+def fib_tab(n):
+
+    table = [0] * (n+1)
+
+    table[1] = 1
+
+    for i in range(2, n+1):
+        table[i] = table[i-1] + table[i-2]
+
+    return table[n]
+
+if __name__ == "__main__":
+    n = int(input("Enter n: "))
+
+    print(f"{n}th fibonacci number is: {fib_tab(n)}")

Diff for: Dynamic Programming/Python/gridTraveller_tab.py

@@ -0,0 +1,23 @@
+# Given a mxn grid, how many ways can I go from the start (0,0) to the end (m,n) by just moving RIGHT or DOWN
+# Time complexity = O(m*n)
+# Space complexity = O(m*n)
+
+def gridTraveller_tab(rows, cols):
+    table = [[0] * (cols+1) for i in range(rows+1)]
+
+    table[1][1] = 1
+
+    for i in range(rows+1):
+        for j in range(cols+1):
+            if(j+1 <= cols):
+                table[i][j+1] += table[i][j]
+            if(i+1 <= rows):
+                table[i+1][j] += table[i][j]
+    
+    return table[rows][cols]
+
+if __name__ == "__main__":
+    m = int(input("Enter number of rows: "))
+    n = int(input("Enter number of cols: "))
+
+    print(f"Number of ways to travel from (1,1) to ({m},{n}): {gridTraveller_tab(m,n)}")