* * Problem: * Given an array of numbers and a number K, we need to remove K numbers from the * array such that we are left with maximum distinct n

* * Problem: * Given N sticks with different lengths, we need to connect these sticks into one big * rope with minimum cost. The cost of connecting

* * Problem: * Given an array of numbers which is sorted in ascending order and also rotated by some * arbitrary number, find the minimum number in

* * Problem: * Given an array of numbers which is sorted in ascending order and also rotated by some * arbitrary number, find the minimum number in

* * Problem: * Given a set of distinct numbers, find all of its permutations. Permutation is * defined as the re-arranging of the elements of the s

* * Problem: * In a non-empty array of integers, every number appears twice except for one, find * that single number. * https://leetcode.com/prob

* * Problem: * Given an array of lowercase letters sorted in ascending order, find the smallest * letter in the given array greater than a given "k

* * Problem: * Given an unsorted array containing numbers, find the smallest missing positive * number in it. * https://leetcode.com/problems/firs

* * Problem: * Given k sorted arrays, find the smallest range that includes at least one number from * each of the k lists. * https://leetcode.com

* * Problem: * Given a set with distinct elements, find all of its distinct subsets. * https://leetcode.com/problems/subsets/ * * Example 1: * I

* * Problem: * Given a set of numbers that might contain duplicates, find all of its distinct * subsets. * https://leetcode.com/problems/subsets-i

* * Problem: * Given an unsorted array of numbers, find the top K frequently occurring numbers in * it. * https://leetcode.com/problems/top-k-freq

* * Problem: * In a non-empty array of numbers, every number appears exactly twice except two * numbers that appear only once. Find the two numbers

* * Problem: * Given a number n, write a function to return all structurally unique Binary Search * Trees (BST) that can store values 1 to n? * *

* * Problem: * Given a binary matrix representing an image, we want to flip the image horizontally, * then invert it. To flip an image horizontally

* * Problem: * Given an array of characters where each character represents a fruit tree, you are given * two baskets and your goal is to put maxim

* * Problem: * Given a word, write a function to generate all of its unique generalized * abbreviations. Generalized abbreviation of a word can be

* * Problem: * For a given number N, write a function to generate all combination of ‘N’ pairs * of balanced parentheses. * https://leetcode.com/p

* * Problem: * Given a binary tree and a number S, find all paths from root-to-leaf such that * the sum of all the node values of each path equals

* * Problem: * Given a binary tree and a number S, find if the tree has a path from * root-to-leaf such that the sum of all the node values of that

* * Problem: * Given a binary tree and a number sequence, find if the sequence is present as a * root-to-leaf path in the given tree. * https://le

* * Problem: * Given a list of non-overlapping intervals sorted by their start time, insert a * given interval at the correct position and merge al

* * Problem: * Given two lists of intervals, find the intersection of these two lists. Each list * consists of disjoint intervals sorted on their s

* * Problem: * Any number will be called a happy number if, after repeatedly replacing it with a * number equal to the sum of the square of all of

* * Problem: * Given the head of a Singly LinkedList, write a method to check if the LinkedList * is a palindrome or not. You algorithm should use

* * Problem: * Given M sorted arrays, find the Kth smallest number among all the arrays. * * Example 1: * Input: L1=[2, 6, 8], L2=[3, 6, 7], L3=[

* * Problem: * Given a binary tree and a node, find the level order successor of the given node * in the tree. The level order successor is the nod

* * Problem: * Given a binary tree, populate an array to represent its level-by-level traversal. * You should populate the values of all nodes of e

* * Problem: * Given a string with lowercase letters only, if you are allowed to replace no more than * k letters with any letter, find the length

* * Problem: * Given a string, find the length of the longest substring without repeating characters. * https://leetcode.com/problems/longest-subst

* * Problem: * Given an array containing 0s and 1s, if you are allowed to replace no more than ‘k’ 0s * with 1s, find the length of the longest con

* * Problem: * Find the path with the maximum sum in a given binary tree. Write a function that * returns the maximum sum. A path can be defined as

* * Problem: * We are given a list of Jobs. Each job has a Start time, an End time, and a CPU * load when it is running. Our goal is to find the ma

* * Problem: * Given an array of positive numbers and a positive number k, find the maximum sum of * any contiguous subarray of size k. * * Examp

* * Problem: * Given an array of numbers and a number k, find the median of all the k sized * sub-arrays (or windows) of the array. * https://leet

* * Problem: * Given a list of intervals, merge all the overlapping intervals to produce a list * that has only mutually exclusive intervals. * ht

* * Problem: * Given an array of K sorted LinkedLists, merge them into one sorted list. * https://leetcode.com/problems/merge-k-sorted-lists/ * *

* * Problem: * Given a list of intervals representing the start and end time of ‘N’ meetings, find * the minimum number of rooms required to hold a

* * Problem: * Find the minimum depth of a binary tree. The minimum depth is the number of nodes * along the shortest path from the root node to th

* * Problem: * Given a string and a pattern, find the smallest substring in the given string which has * all the characters of the given pattern.

* * Problem: * Given a string and a pattern, find out if the string contains any permutation of the * pattern. * https://leetcode.com/problems/per

* * Problem: * Given an array of unsorted numbers and a target number, find all unique quadruplets in * it, whose sum is equal to the target number

* * Problem: * Given an array of sorted numbers, remove all duplicates from it. You should not use any * extra space; after removing the duplicates

* * Problem: * Given the head of a LinkedList and a number k, reverse every alternating k * sized sub-list starting from the head. If, in the end,

* * Problem: * Given the head of a LinkedList and a number k, reverse every k sized sub-list * starting from the head. If, in the end, you are left

* Do it recursively.

* * Problem: * Given a binary tree, populate an array to represent its level-by-level traversal * in reverse order, i.e., the lowest level comes fi

* * Problem: * Given a binary tree, return an array containing nodes in its right view. The right * view of a binary tree is the set of nodes visib

* A recursive solution which does not require storing all level nodes. The key * logic is to do DFS traversal but visiting the right node first, beca

* * Problem: * Given a linked list, rotate the list to the right by k places, where k is * non-negative. * https://leetcode.com/problems/rotate-li

* * Problem: * You are given a list of tasks that need to be run, in any order, on a server. Each task * will take one CPU interval to execute but

* * Problem: * Follow up on the 33_search-in-rotated-sorted-array problem, how do we search in a * sorted and rotated array that also has duplicate

* * Problem: * Given an array, find the length of the smallest subarray in it which when sorted * will sort the whole array. * https://leetcode.co

* * Problem: * Given an array of positive numbers and a positive number ‘S’, find the length * of the smallest contiguous subarray whose sum is gre

* * Problem: * Given a string, sort it based on the decreasing frequency of its characters. * https://leetcode.com/problems/sort-characters-by-freq

* * Problem: * Given an array containing 0s, 1s and 2s, sort the array in-place. You should treat * numbers of the array as objects, hence, we can’

* * Problem: * Given a sorted array, create a new array containing squares of of the input array in * the sorted order. * https://leetcode.com/pr

* * Problem: * Given an array with positive numbers and a target number, find all of its contiguous * subarrays whose product is less than the targ

* * Problem: * Given a string and a list of words, find all the starting indices of substrings in the * given string that are a concatenation of al

* * Problem: * Given an array, find the sum of all numbers between the K1'th and K2'th smallest * elements (not inclusive) of that array. * * Exa

* * Problem: * Given a binary tree where each node can only have a digit (0-9) value, each * root-to-leaf path will represent a number. Find the to

* * Problem: * Topological Sort of a directed graph (a graph with unidirectional edges) is a linear * ordering of its vertices such that for every

* * Problem: * Given an array of unsorted numbers and a target number, find a triplet in the array * whose sum is as close to the target number as

* * Problem: * Given an array of unsorted numbers, find all unique triplets in it that add up to zero. * Notice that the solution set must not cont

* * Problem: * Given an array arr of unsorted numbers and a target sum, count all triplets in it such * that arr[i] + arr[j] + arr[k] < target wher

* * Problem: * Given an array of sorted numbers and a target sum, find a pair in the array whose sum * is equal to the given target. Write a functi

* * Problem: * Given a binary tree, populate an array to represent its zigzag level order * traversal. You should populate the values of all nodes

* * @param {number[]} candidates * @param {number} target * @param {number} currentIndex * @param {number[]} currentArr * @param {number[][]} com

* * Follow the same approach as 95_unique-binary-search-trees-ii, but this time we * can use memoization because the result is just a plain number (

* * @param {number[]} sources * @param {number[][]} graph * @param {number[]} inDegrees * @param {boolean[]} used * @param {number[]} currentResu

* Compare `word1` and `word2` to find a order between 2 characters. * * Time: O(m) m: max length of `word1` and `word2` * * @param {string} word1

* * Time: O(mn) m: 2 * targetSum * Space: O(mn) <- for `memo` and recursion stack * * @param {number[]} nums * @param {number} targetSum * @para

* * The only changing variables are `currentIndex` and `targetSum`, so use two-dimension * `memo` to prevent duplication sub-problems. * * Time: O

* * Time: O(mn) m: target sum * Space: O(mn) <- for `memo` and recursion stack * * @param {*} nums * @param {*} targetSum * @param {*} currentIn

* * Time: O(mn) m: total sum * Space: O(mn) * * @param {number[]} nums * @param {number} totalSum * @param {number} currentSum * @param {number

* * From the above solution 1, we can easily identify that each call of `_recursive` * the only changing variables are `currentIndex` and `capacity`