Memolization and tabulization

Author: MdSamsuzzohaShayon

dynamic_programming/01_fibonacci_sequence.js dynamic_programming/01_memolization/01_fibonacci_sequence.js

@@ -0,0 +1,101 @@
+/**
+ * 02:12:45 - https://youtu.be/oBt53YbR9Kk?t=7965
+ * 
+ * Problem:
+ * Write a function `canConstruct(target, wordBank)` that accepts a target and an array of strings.
+ * The function should return a boolean indicating whether or not the `target` can be constructed 
+ * by concatenating elements of `wordBank` array.
+ * You may reuse elements of `wordBank` as many times as needed.
+ */
+
+/**
+ * Brute Force Approach
+ * This function attempts to solve the problem using recursion without any optimizations.
+ * @param {string} target - The target string we want to construct.
+ * @param {string[]} wordBank - The array of words that can be used to construct the target.
+ * @returns {boolean} - Returns true if the target can be constructed, otherwise false.
+ */
+function canConstruct(target, wordBank) {
+    // Base case: If the target is an empty string, we can construct it by using zero words.
+    if (target === '') {
+        return true;
+    }
+
+    // Iterate over each word in the wordBank
+    for (const word of wordBank) {
+        // Check if the word is a prefix of the target
+        if (target.indexOf(word) === 0) {
+            // If it is, we create a new target by removing the prefix (word)
+            const suffix = target.slice(word.length);
+            // Recursively check if we can construct the new target (suffix) with the wordBank
+            if (canConstruct(suffix, wordBank)) {
+                return true;
+            }
+        }
+    }
+
+    // If no combination of words can construct the target, return false
+    return false;
+}
+
+console.log("===== Brute Force =====");
+
+// Brute Force
+// m = target.length
+// n = wordBank.length
+// Time Complexity: O(n^m * m)
+// In the worst case, we have to explore all combinations of the wordBank for each character in the target.
+// Space Complexity: O(m^2)
+// Due to the call stack and slicing of strings.
+console.log(canConstruct('abcdef', ['ab', 'abc', 'cd', 'abcd'])); // true
+console.log(canConstruct('skateboard', ['bo', 'rd', 'ate', 't', 'ska', 'sk', 'boar'])); // false
+console.log(canConstruct('enterapotentpot', ['a', 'p', 'ent', 'enter', 'ot', 'o', 't'])); // true
+console.log(canConstruct('eeeeeeeeeeeeeeeeeeeeeeeeeef', ['e', 'ee', 'eee', 'eeee', 'eeeee', 'eeeeee'])); // false
+
+
+/**
+ * Optimized Approach using Memoization
+ * This function optimizes the brute force approach by using memoization to store the results of subproblems.
+ * @param {string} target - The target string we want to construct.
+ * @param {string[]} wordBank - The array of words that can be used to construct the target.
+ * @param {object} memo - An object used to store the results of subproblems.
+ * @returns {boolean} - Returns true if the target can be constructed, otherwise false.
+ */
+function optimizedCanConstruct(target, wordBank, memo = {}) {
+    // Check if the result for the current target is already in the memo
+    if (target in memo) return memo[target];
+    // Base case: If the target is an empty string, we can construct it by using zero words.
+    if (target === '') return true;
+
+    // Iterate over each word in the wordBank
+    for (const word of wordBank) {
+        // Check if the word is a prefix of the target
+        if (target.indexOf(word) === 0) {
+            // If it is, we create a new target by removing the prefix (word)
+            const suffix = target.slice(word.length);
+            // Recursively check if we can construct the new target (suffix) with the wordBank
+            if (optimizedCanConstruct(suffix, wordBank, memo)) {
+                // Store the result in the memo and return true
+                memo[target] = true;
+                return true;
+            }
+        }
+    }
+
+    // Store the result in the memo and return false
+    memo[target] = false;
+    return false;
+}
+
+console.log("===== Memoization =====");
+// Memoization
+// m = target.length
+// n = wordBank.length
+// Time Complexity: O(n * m^2)
+// For each character in the target (m), we iterate over the wordBank (n) and slice the string (m).
+// Space Complexity: O(m^2)
+// Due to the memo object and the call stack.
+console.log(optimizedCanConstruct('abcdef', ['ab', 'abc', 'cd', 'abcd'])); // true
+console.log(optimizedCanConstruct('skateboard', ['bo', 'rd', 'ate', 't', 'ska', 'sk', 'boar'])); // false
+console.log(optimizedCanConstruct('enterapotentpot', ['a', 'p', 'ent', 'enter', 'ot', 'o', 't'])); // true
+console.log(optimizedCanConstruct('eeeeeeeeeeeeeeeeeeeeeeeeeef', ['e', 'ee', 'eee', 'eeee', 'eeeee', 'eeeeee'])); // false

dynamic_programming/02_grid_traveler.js dynamic_programming/01_memolization/02_grid_traveler.js

@@ -0,0 +1,96 @@
+/**
+ * 02:38:35 - https://youtu.be/oBt53YbR9Kk?t=9515
+ * 
+ * Problem:
+ * Write a function `countConstruct(target, wordBank)` that accepts a target string and an array of strings.
+ * The function should return the number of ways that the `target` can be constructed by concatenating elements of the `wordBank` array.
+ * You may reuse elements of `wordBank` as many times as needed.
+ */
+
+/**
+ * Brute Force Approach
+ * This function attempts to solve the problem using recursion without any optimizations.
+ * @param {string} target - The target string we want to construct.
+ * @param {string[]} wordBank - The array of words that can be used to construct the target.
+ * @returns {number} - Returns the number of ways the target can be constructed.
+ */
+function countConstruct(target, wordBank) {
+    // Base case: If the target is an empty string, there is one way to construct it (by using no words).
+    if (target === '') return 1;
+
+    let totalCount = 0;
+
+    // Iterate over each word in the wordBank
+    for (const word of wordBank) {
+        // Check if the word is a prefix of the target
+        if (target.indexOf(word) === 0) {
+            // If it is, we create a new target by removing the prefix (word)
+            const numWaysForRest = countConstruct(target.slice(word.length), wordBank);
+            // Add the number of ways to construct the rest of the target to the total count
+            totalCount += numWaysForRest;
+        }
+    }
+
+    return totalCount;
+}
+
+console.log("===== Brute Force =====");
+
+// Brute Force
+// m = target.length
+// n = wordBank.length
+// Time Complexity: O(n^m * m)
+// In the worst case, we have to explore all combinations of the wordBank for each character in the target.
+// Space Complexity: O(m^2)
+// Due to the call stack and slicing of strings.
+console.log(countConstruct('purple', ['purp', 'p', 'ur', 'le', 'purpl'])); // 2
+console.log(countConstruct('abcdef', ['ab', 'abc', 'cd', 'abcd'])); // 1
+console.log(countConstruct('skateboard', ['bo', 'rd', 'ate', 't', 'ska', 'sk', 'boar'])); // 0
+console.log(countConstruct('enterapotentpot', ['a', 'p', 'ent', 'enter', 'ot', 'o', 't'])); // 4
+console.log(countConstruct('eeeeeeeeeeeeeeeeeeeeeeeeeef', ['e', 'ee', 'eee', 'eeee', 'eeeee', 'eeeeee'])); // 0
+
+/**
+ * Optimized Approach using Memoization
+ * This function optimizes the brute force approach by using memoization to store the results of subproblems.
+ * @param {string} target - The target string we want to construct.
+ * @param {string[]} wordBank - The array of words that can be used to construct the target.
+ * @param {object} memo - An object used to store the results of subproblems.
+ * @returns {number} - Returns the number of ways the target can be constructed.
+ */
+function optimizedCountConstruct(target, wordBank, memo = {}) {
+    // Check if the result for the current target is already in the memo
+    if (target in memo) return memo[target];
+    // Base case: If the target is an empty string, there is one way to construct it (by using no words).
+    if (target === '') return 1;
+
+    let totalCount = 0;
+
+    // Iterate over each word in the wordBank
+    for (const word of wordBank) {
+        // Check if the word is a prefix of the target
+        if (target.indexOf(word) === 0) {
+            // If it is, we create a new target by removing the prefix (word)
+            const numWaysForRest = optimizedCountConstruct(target.slice(word.length), wordBank, memo);
+            // Add the number of ways to construct the rest of the target to the total count
+            totalCount += numWaysForRest;
+        }
+    }
+
+    // Store the result in the memo and return the total count
+    memo[target] = totalCount;
+    return totalCount;
+}
+
+console.log("===== Memoization =====");
+// Memoization
+// m = target.length
+// n = wordBank.length
+// Time Complexity: O(n * m^2)
+// For each character in the target (m), we iterate over the wordBank (n) and slice the string (m).
+// Space Complexity: O(m^2)
+// Due to the memo object and the call stack.
+console.log(optimizedCountConstruct('purple', ['purp', 'p', 'ur', 'le', 'purpl'])); // 2
+console.log(optimizedCountConstruct('abcdef', ['ab', 'abc', 'cd', 'abcd'])); // 1
+console.log(optimizedCountConstruct('skateboard', ['bo', 'rd', 'ate', 't', 'ska', 'sk', 'boar'])); // 0
+console.log(optimizedCountConstruct('enterapotentpot', ['a', 'p', 'ent', 'enter', 'ot', 'o', 't'])); // 4
+console.log(optimizedCountConstruct('eeeeeeeeeeeeeeeeeeeeeeeeeef', ['e', 'ee', 'eee', 'eeee', 'eeeee', 'eeeeee'])); // 0

dynamic_programming/03_can_sum.js dynamic_programming/01_memolization/03_can_sum.js

@@ -0,0 +1,103 @@
+/**
+ * 02:47:30 - https://youtu.be/oBt53YbR9Kk?t=10050
+ *
+ * 
+ * Problem: 
+ * Write a function `allConstruct(target, wordBank)` that accepts a target string and an array of strings.
+ * This function should return a 2D array containing all the ways that `target` can be constructed by concatenating elements of the `wordBank` array.
+ * Each element of the 2D array should represent one combination that constructs the `target`
+ * You may reuse elements of `wordBank` as many times as needed.
+ */
+
+/**
+ * Brute Force Approach
+ * This function attempts to solve the problem using recursion without any optimizations.
+ * @param {string} target - The target string we want to construct.
+ * @param {string[]} wordBank - The array of words that can be used to construct the target.
+ * @returns {string[][]} - Returns a 2D array containing all the ways to construct the target.
+ */
+function allConstruct(target, wordBank) {
+    // Base case: If the target is an empty string, return an array containing an empty array
+    if (target === '') return [[]];
+
+    const result = [];
+
+    // Iterate over each word in the wordBank
+    for (const word of wordBank) {
+        // Check if the word is a prefix of the target
+        if (target.indexOf(word) === 0) {
+            // If it is, we create a new target by removing the prefix (word)
+            const suffix = target.slice(word.length);
+            // Recursively find all ways to construct the suffix
+            const suffixWays = allConstruct(suffix, wordBank);
+            // For each way to construct the suffix, add the current word to the beginning
+            const targetWays = suffixWays.map(way => [word, ...way]);
+            // Add all the ways to construct the target to the result array
+            result.push(...targetWays);
+        }
+    }
+
+    return result;
+}
+
+// Brute Force
+// m = target.length
+// n = wordBank.length
+// Time Complexity: O(n^m)
+// Each recursive call spawns n new recursive calls, leading to exponential time complexity.
+// Space Complexity: O(m)
+// The maximum depth of the recursion tree is m.
+console.log("===== Brute Force =====");
+console.log(allConstruct("purple", ["purp", "p", "ur", "le", "purpl"])); // [ [ 'purp', 'le' ], [ 'p', 'ur', 'p', 'le' ] ]
+console.log(allConstruct("abcdef", ["ab", "abc", "cd", "def", "abcd", "ef", "c"])); // [ [ 'ab', 'cd', 'ef' ], [ 'ab', 'c', 'def' ], [ 'abc', 'def' ], [ 'abcd', 'ef' ] ]
+console.log(allConstruct('skateboard', ['bo', 'rd', 'ate', 't', 'ska', 'sk', 'boar'])); // []
+console.log(allConstruct('aaaaaaaaaaaaaaaaaaaaaaaaaaz', ['a', 'aa', 'aaa', 'aaaa', 'aaaaa', 'aaaaaa'])); // []
+
+/**
+ * Optimized Approach using Memoization
+ * This function optimizes the brute force approach by using memoization to store the results of subproblems.
+ * @param {string} target - The target string we want to construct.
+ * @param {string[]} wordBank - The array of words that can be used to construct the target.
+ * @param {object} memo - An object used to store the results of subproblems.
+ * @returns {string[][]} - Returns a 2D array containing all the ways to construct the target.
+ */
+function optimizedAllConstruct(target, wordBank, memo = {}) {
+    // Check if the result for the current target is already in the memo
+    if (target in memo) return memo[target];
+    // Base case: If the target is an empty string, return an array containing an empty array
+    if (target === '') return [[]];
+
+    const result = [];
+
+    // Iterate over each word in the wordBank
+    for (const word of wordBank) {
+        // Check if the word is a prefix of the target
+        if (target.indexOf(word) === 0) {
+            // If it is, we create a new target by removing the prefix (word)
+            const suffix = target.slice(word.length);
+            // Recursively find all ways to construct the suffix
+            const suffixWays = optimizedAllConstruct(suffix, wordBank, memo);
+            // For each way to construct the suffix, add the current word to the beginning
+            const targetWays = suffixWays.map(way => [word, ...way]);
+            // Add all the ways to construct the target to the result array
+            result.push(...targetWays);
+        }
+    }
+
+    // Store the result in the memo and return the total count
+    memo[target] = result;
+    return result;
+}
+
+console.log("===== Memoization =====");
+// Memoization
+// m = target.length
+// n = wordBank.length
+// Time Complexity: O(n * m)
+// Each target string can be constructed in a number of ways proportional to its length, leading to polynomial time complexity.
+// Space Complexity: O(m)
+// Due to the memo object and the call stack.
+console.log(optimizedAllConstruct("purple", ["purp", "p", "ur", "le", "purpl"])); // [ [ 'purp', 'le' ], [ 'p', 'ur', 'p', 'le' ] ]
+console.log(optimizedAllConstruct("abcdef", ["ab", "abc", "cd", "def", "abcd", "ef", "c"])); // [ [ 'ab', 'cd', 'ef' ], [ 'ab', 'c', 'def' ], [ 'abc', 'def' ], [ 'abcd', 'ef' ] ]
+console.log(optimizedAllConstruct('skateboard', ['bo', 'rd', 'ate', 't', 'ska', 'sk', 'boar'])); // []
+console.log(optimizedAllConstruct('aaaaaaaaaaaaaaaaaaaaaaaaaaaz', ['a', 'aa', 'aaa', 'aaaa', 'aaaaa', 'aaaaaa'])); // []