* * Solution 2: top-down dynamic programming with memoization. * * @param {number[]} nums * @return {boolean}

* * Solution 3: bottom-up dynamic programming. * * Time: O(mn) m: target sum <- loop to populate `dp` * Space: O(mn) <- for the `dp` * * @param

* * Solution 4: bottom-up dynamic programming with reduced space. * * Time: O(mn) m: target sum <- loop to populate `dp` * Space: O(m) <- for the

* If the tree is a perfect binary tree (where each node must have 2 children expect * the leaf nodes), the above solution can be simplified further.

* O(1) space solution which does not require storing all level nodes.

* * Give a number `target`, find out how many numbers in the matrix are less than * or equal to `target`. * * Time: O(n) * * @param {number[][]}

* A more simplified solution: the tricky part is to understand the count * of [i + 1, n] can be treated as the same count of [1, n - (i + 1) + 1]. *

* A non-recursive version based on countUniqueBST2() above. * Time: O(n^2)

* A more general solution with backtracking, if we think the whole process as * a tree, the constructing of the subsets is like DFS of the tree. *

* * Solution 1: recursive brute-force way. * * @param {number[]} weights * @param {number[]} profits * @param {number} capacity * @return {numbe

* * Solution 2: recursion with memoization, also called top-down dynamic programming * with memoization. * * Why we call it "top-down", because wh

* * Solution 3: bottom-up dynamic programming. * Similar as "Solution 2" above, we still want to calculate all the possible combinations * of `inde

* * Solution 4: bottom-up dynamic programming with reduced space. * Similar as "Solution 3" above, but if we look the transition function we get *

* * Another solution with binary search. * Binary search requires the search space is sorted, how does this row/col-based * matrix achieve this? Th

* * Problem: * Given an N * N matrix where each row and column is sorted in ascending order, find * the Kth smallest element in the matrix. * http

* * Problem: * Given a set of investment projects with their respective profits, we need to find * the most profitable projects. We are given an in

* * Problem: * Given the head of a Singly LinkedList, write a method to modify the LinkedList * such that the nodes from the second half of the Lin

* * Problem: * Given the head of a Singly LinkedList, reverse the LinkedList. Write a function to * return the new head of the reversed LinkedList.

* Do the reversion in the recursive manner.

* * Problem: * Given the head of a LinkedList and two positions "p" and "q" (1-based), reverse the * LinkedList from position "p" to "q". * https:

* * Time: O(n log(n)) * Space: O(k) * * @param {number} k * @param {number[]} nums

* It's intuitive to use heap here, because for each pop() we need to get the highest * frequency number quickly, which means for each push() we sho

* Not that intuitive but more efficient solution. Besides the frequency map (key is * number and value is the frequency), we also maintain another

* * Time: O(1) * * @return {number}

* * Time: O(1) * * @param {number} num * @return void