Provide a number which is not assigned to anyone. @return - Return an available number. Return -1 if none is available.

Check key in cache. If not in cache, return -1. If in cache, get the node, move it to head, return its value.

Push x to stack. After that, check min stack. Push to min stack if min stack is empty or x is smaller than the top of min stack.

Pop from s. Check if the value is current min. If it is, pop from min stack as well.

Removes a value from the set. Returns true if the set contained the specified element. Check if the value exists. If not, nothing to remove, return fa

Inserts a word into the trie.

Sum of two bits can be obtained by performing XOR (^) of the two bits. Carry bit can be obtained by performing AND (&) of two bits.

Removes a value from the collection. Returns true if the collection contained the specified element.

Array. In-place solution. Skip the non-overlapping intervals whose end time is before new interval's start. For overlapped intervals that start before

Optimized DP Build a stack for indices of open parentheses Traverse the string, if current is open paren, push to stack Otherwise, its close paren. If

Calculate the start point of next round with: The start point of this round, the step, the number of removed integers. If from left, start = start + s

Returns if the word is in the trie.

Binary search to locate row, then binary search in a row O(logm + logn)

Hash Table. Store the previous seen index of a character. 0 means not seen yet. If the last seen indices are different, return false. Update index to

DP. Space Optimized. Max amount of house n is either rob the previous house or rob this house. Recurrence relation: max[n] = max(max[n - 2] + nums[n],

If key already in cache, only need to update value: | Get the node, update its value, move to head. If key is not in cache: | Create a new node. | Add

Returns if there is any word in the trie that starts with the given prefix.

Binary Search. The original thought is binary search from 1 to sqrt(n). Since we cannot use built-in library, we use n / 2 to replace it. Note that n

Math. A perfect square is the sum of a consecutive odd number sequence. 1 + 3 + 5 + 7 + 9 ... For example: 1 = 1, 4 = 1 + 3, 9 = 1 + 3 + 5, 16 = 1 + 3

Math, Newton's Method. x(n+1) = x(n) - f(x(n)) / f'(x(n)) Find the root for y = num - t^2. t - (num - t^2) / -2t = t + num / 2t - t / 2 = (t + num / t

Compare 2 lists ignoring order.

1) Initialize sum as 0 and index as index+1. 2) Do following while index is greater than 0. ...a) Add BITree[index] to sum ...b) Go to parent of BITre

DP. O(mn) Time, O(mn) Space. match[i][j]: whether s[0..i-1] matches p[0..j-1] Recurrence relations: if p[j - 1] != ' ': | p[j - 1] is a letter or a '.

Clarify whether negative nums are palindrom first Compare each digit

Each cut at i+j is calculated by scanning (i-j)'s minimum cut + 1 if s[i-j, i+j] is a palindrome.

The AND result of the last bit of odd and even numbers should be 0. So if m and n are not equal, check the last bit of them. Count the number of itera

Two-pointer swapping

Number of decodings of one single character. If ' ', it can be any one between 1-9, 9 ways. If '0', it cannot be decoded, 0. Else just 1.

Initialize a list of digits to build the result Build from first character

Two pointers start from the head of A & B O(k)

Create an index mapping. [0, 1, 2, 3, 4, 5] -> [1, 3, 5, 0, 2, 4] [0, 1, 2, 3, 4, 5, 6] -> [1, 3, 5, 0, 2, 4, 6]

Create a dummy head and check the next element. If the element is head, the head needs to be updated. If in the middle, we skip this element by connec

Use two pointers, search for vowels from both ends

Sliding window. Remember where the current sub-sequence started as start. When a[i-1] >= a[i], i-start+1 is the length of current continuous increasin

DP. Current sub-sequence length, len, is incremented when the next number is larger. When len is incremented, check if longest length max should be up

O(n) Time, O(n) Space Maintain a window and add elements to the window till it contains less or equal k Update our result if required while doing so.

Recursive solution with in-order traversal helper.

DP. Can either buy or sell on day i, 2 states. Track the maximum of these 2 states. If buy, the maximum is either do nothing or buy today's stock with

Stack, Greedy. Find the last digit of the increasing sequence and the first digit of the decreasing sequence. Remove it and decrement k by 1. Why is i

Stack, Greedy. The only difference is that stack is imitated with an Object(Character) array and a pointer to its top. Because we know the largest pos

Stack. Split path with slash, there can be 4 situations: 1) A correct name, push into stack. 2) A dot, skip. 3) Double dot, should pop last directory

Possible results range from 0 to 9. Only when num is 0, the result is 0; Otherwise, the result is within 1 to 9. It happens periodically as the num in

Get the lengths of the two lists first, the difference of which can be used to add list nodes. If the diff is 0, the nodes can be added. If the diff i

Union Find. The pairs given can be treated as graph edges. Each word is a node. Similar words are connected. Dissimilar words are not. Connected words

Dynamic Programming Keep track of the maximum of jumps we left Initialized as A[0] Traverse from second to second last Reduce 1 every time we jump max

Math, Bézout's identity. Let a and b be nonzero integers and let d be their greatest common divisor. Then there exist integers x and y such that ax+by

DFS. Iterative.

Greedy. When two intervals overlap with each other, we have to remove one of them. Which one? The one with larger end. Why? When intervals are sorted

Stack. Suppose all reverse polish are valid. For each token t in tokens: | If t is an operator: | Pop two numbers and do the calculation. | Push r

O(n), find the root id. If p equals id[p], p is root.