added copyListWithRandomPointer

solutions/dp/climbingStairs.js

@@ -41,3 +41,22 @@ const climbStairs = (n) => {
 
   return cache[n];
 };
+
+/*
+BETTER BOTTOM-UP DP SOLUTION
+*/
+const climbStairs = (n) => {
+  if (n <= 2) return n;
+
+  let oneStepBack = 2;
+  let twoStepsBack = 1;
+  let totalWaysToReachI = 0;
+
+  for (let i = 2; i < n; i++) {
+    totalWaysToReachI = oneStepBack + twoStepsBack;
+    twoStepsBack = oneStepBack;
+    oneStepBack = totalWaysToReachI;
+  }
+
+  return totalWaysToReachI;
+};

solutions/dp/fibonacciNumber.js

@@ -48,3 +48,22 @@ const fib = (n) => {
 
   return cache[n];
 };
+
+/*
+BETTER BOTTOM-UP DP SOLUTION
+*/
+const fib = (n) => {
+  if (n <= 1) return n;
+
+  let curFib = 0;
+  let lastFib = 1;
+  let lastLastFib = 0;
+
+  for (let i = 2; i <= n; i++) {
+    curFib = lastFib + lastLastFib;
+    lastLastFib = lastFib;
+    lastFib = curFib;
+  }
+
+  return curFib;
+};

solutions/dp/houseRobber.js

@@ -0,0 +1,15 @@
+/*
+BOTTOM-UP DP SOLUTION
+*/
+const rob = (nums) => {
+    let previousTotalRobbed = 0;
+    let currentTotalRobbed = 0;
+
+    nums.forEach((money) => {
+        const temp = currentTotalRobbed; 
+        currentTotalRobbed = Math.max(previousTotalRobbed + money, currentTotalRobbed);
+        previousTotalRobbed = temp;
+    });
+
+    return currentTotalRobbed;
+};

solutions/dp/houseRobberII.js

@@ -0,0 +1,34 @@
+const robHelper = (nums, startIdx) => {
+    let previousTotalRobbed = 0;
+    let currentTotalRobbed = 0;
+    let temp;
+
+    const numHousesAccountingForPotentialSkips = nums.length - 1 + startIdx;
+    for (let i = startIdx; i < numHousesAccountingForPotentialSkips; i++) {
+        const money = nums[i];
+
+        temp = currentTotalRobbed; 
+        currentTotalRobbed = Math.max(previousTotalRobbed + money, currentTotalRobbed);
+        previousTotalRobbed = temp;
+    }
+
+    return currentTotalRobbed;
+};
+
+/*
+BOTTOM-UP DP SOLUTION
+*/
+const rob = (nums) => {
+    const firstHouseMoney = nums[0];
+    if (nums.length === 1) {
+        return firstHouseMoney;
+    }
+    if (nums.length === 2) {
+        const secondHouseMoney = nums[1];
+        return Math.max(firstHouseMoney, secondHouseMoney);
+    }
+
+    const maxMoneyIfSkipFirstHouse = robHelper(nums, 1);
+    const maxMoneyIfDontSkipFirstHouse = robHelper(nums, 0);
+    return Math.max(maxMoneyIfSkipFirstHouse, maxMoneyIfDontSkipFirstHouse);
+};

solutions/dp/maximumSubarray

@@ -0,0 +1,16 @@
+/*
+BOTTOM-UP DP SOLUTION
+*/
+const maxSubArray = (nums) => {
+    let currentSubarraySum = nums[0];
+    let maxSubarraySum = nums[0];
+
+    for (let i = 1; i < nums.length; i++) {
+        let number = nums[i];
+
+        currentSubarraySum = Math.max(number, currentSubarraySum + number);
+        maxSubarraySum = Math.max(maxSubarraySum, currentSubarraySum);
+    }
+
+    return maxSubarraySum;
+};

solutions/dp/perfectSquares.js

@@ -0,0 +1,27 @@
+/*
+BOTTOM-UP DP SOLUTION
+*/
+const numSquares = (n) => {
+    const cache = new Array(n + 1);
+    cache.fill(Infinity);
+    cache[0] = 0;
+
+    for (let target = 1; target <= n; target++) {
+        let integer = 1;
+        let perfectSquare = 1;
+        while (perfectSquare <= target) {
+            cache[target] = Math.min(
+                cache[target],
+                cache[target - perfectSquare] + 1,
+            );
+            integer++;
+            perfectSquare = integer * integer;
+        }
+    }
+
+    return cache[n];
+};
+
+/*
+TOP-DOWN DP SOLUTION
+*/

solutions/dp/wordBreak.js

@@ -0,0 +1,53 @@
+/*
+TOP-DOWN DP SOLUTION
+*/
+
+/**
+ * Reduces a sequence of names to initials.
+ * @param  {String} s a string containing potential words
+ * @param  {Set} wordSet a set containing all valid words
+ * @param  {Number} start an index in s indicating where to start
+ * @param  {Object} cache cache Object
+ * @return {Boolean} whether or not the string can be broken up into words
+ */
+const wordBreakHelper = (s, wordSet, start, cache) => {
+    if (cache.has(start)) return false;
+    if (start === s.length) return true;
+
+    for (let end = start + 1; end < s.length + 1; end++) {
+        const potentialWord = s.slice(start, end);
+
+        if (wordSet.has(potentialWord)) {
+            if (wordBreakHelper(s, wordSet, end, cache)) return true;
+        }
+    }
+
+    cache.add(start);
+    return false;
+};
+
+const wordBreak = (s, wordDict) => {
+    const wordSet = new Set(wordDict);
+    return wordBreakHelper(s, wordSet, 0, new Set());
+};
+
+/*
+BOTTOM-UP DP SOLUTION
+*/
+const wordBreak = (s, wordDict) => {
+    const wordSet = new Set(wordDict);
+    const cache = new Array(s.length + 1);
+    cache.fill(false);
+    cache[0] = true;
+
+    for (let end = 1; end <= s.length; end++) {
+        for (let start = 0; start < end; start++) {
+            const w = s.slice(start, end);
+            if (cache[start] === true && wordSet.has(w)) {
+                cache[end] = true;
+            }
+        }
+    }
+
+    return cache[s.length];
+};

solutions/linked-lists/copyListWithRandomPointer.js

@@ -0,0 +1,60 @@
+const copyRandomList = (head) => {
+    let copies = new Map();
+    copies.set(null, null);
+
+    let current = head;
+
+    while (current) {
+        const copy = new Node(current.val);
+        copies.set(current, copy);
+        current = current.next;
+    }
+
+    current = head;
+
+    while (current) {
+        const copy = copies.get(current);
+        copy.next = copies.get(current.next);
+        copy.random = copies.get(current.random);
+        current = current.next;
+    }
+
+    return copies.get(head);
+};
+
+/*
+O(1) space solution. Honestly, don't even worry about knowing how to do this.
+*/
+const copyRandomList = (head) => {
+    if (!head) return null;
+
+    let current = head;
+
+    while (current) {
+        let copy = new Node(current.val, current.next, null);
+        copy.next = current.next;
+        current.next = copy;
+        current = current.next;
+        current = current.next;
+    }
+
+    current = head;
+
+    while(current) {
+        current.next.random = current.random ? current.random.next : null;
+        current = current.next.next;
+    }
+
+    current = head;
+    let copy = head.next;
+    let copyPointer = copy;
+
+    while(current) {
+        current.next = current.next.next;
+        current = current.next;
+        copyPointer.next = copyPointer.next ? copyPointer.next.next : null;
+        copyPointer = copyPointer.next;
+    }
+
+    return copy;
+};