DFS, BFS. Intuition: The closest leaf of a node is actually the minimum distance from the node to the boundary of the tree. If we treat tree generally

If input c is '#': 1. Update trie with full sentence. 2. Reset variables, like previous node and prefix. 3. Return an empty list. Else the sentence is

DP f[n][i][j] means isScramble(s1[i: i+n], s2[j: j+n]) f[n][i][j] = f[k][i][j] && f[n - k][i+k][j+k] || f[k][i][j+n-k] && f[n-k][i+k][j]

Greedy. Go through intervals and keep only overlapping ones. | If none, return 0. Sort the overlapping intervals by start first. For each overlapping

Recursive. Recurrence Relation: Pick the node with smaller value as current head h. Then concatenate h with the merged result of h.next and the other

Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter.

Two Pointers. For i from 0 to m-n: | For j from 0 to n-1: | If characters are not the same, break | If j reaches the end of needle, return i. Retu

Use a map to store frequency. Create a bucket of lists, indexed by frequency. Each list contains the number of that frequency.

backtrace program using bit-wise operation to speed up calculation. 'limit'is all '1's. 'h' is the bits all the queens vertically projected on a ro

O(n), connect two points to the same root. Every time we union two points, the count will decrease by 1.

Bit Manipulation. How to use bit masks to get how many bytes?

Whitespace, sign, out of range Trim the unnecessary whitespaces initialize a variable as long to store the result use a boolean as a flag to mark whet

Hash Table. O(n) Time, O(n) Space. Continuous / Contiguous problem seems to always need to combine the array elements somehow. Sum the values and mod

DP. O(n^2) Time, O(n) Space. Keep the sum from each index to current index in an array.

Stack. Let's say we are now at temperatures[i], t[i]. We need to: 1. Update all t[j], j in [0..i-1], that t[j] < t[i]. 2. t[j] has not been updated. H

Find value in BST. If root is null, return null. If val is on interval's left, find in left subtree. If val is on interval's right, find in right subt

BFS addRecursive the start point to a queue, and set it as visited Convert 2d coordinate to 1d integer and store it in queue While the queue is not em

Hash table. Save count of each character in a map. Then find the first one that has count as 1. If the count array stores count and index, another lin

Recursive Check current node Check left subtree Compare with current node and set predecessor Check right subtree

Iterasive solution with stack.

Binary search for left subtree node count. For BST, the # of nodes of left subtree is actually the node's ranking.

Greedy. Observations: 1. 9 is the largest number with monotone increasing digits(MID) of single digits. 2. Go from MSB to LSB, if we keep current digi

@return the next smallest number s

Remove an interval from BST and return a updated root node. If root is null, return null. If interval is null, nothing to remove, return root. If inte

If current house is robbed, then subtrees' roots cannot be robbed. The maximum is root.val + rob(root.left.left) + rob(root.left.right) + rob(root.rig

3 cases: 1. Remove leftmost character, check if the remaining string is a palindrome. 2. Remove rightmost character, check if the remaining string is

DP, Greedy. Use two vars to record the count of increasing-first and decreasing-first sequences. Then loop through the array from second number. If cu

Insert a new key into the BST. If root is null, create a new root with the given value. If val < root.interval.start, should insert to the left subtre

Add a node after head.

Adds a word into the data structure.

BFS. Traverse each level of the binary tree.

DFS.

Backtracking. Statement: Given board, starting position, word, and current position in word. Find whether the word is in board. Recursion: Check curre

DP, bottom-up. Recurrence relation: canCross[i][j] denotes the state whether the frog can cross at stone i+1 with j steps For any j < i, distance = st

Math Given a number and a base, convert the number

DP. Regard a palindrome string as 2 parts: 1. The 2 chars at both ends. 2. The inner substring. So a substring from i to j is a palindrome if: 1. The

Brute-force. Check if each char or 2 chars can be the center of a palindrome.

DP. Number positions do not matter, only the counts matter. When a number is deleted, all its neighbors are deleted. So no other numbers can delete th

Set a pre pointer

Backtracking. What kind of data do we need to preserve for between recursive calls? Of course the result list we are going to generate. And the origin

@param ps start index of preorder, inclusive @param pe end index of preorder, inclusive @param is start index of inorder, inclusive @param ie end inde

DFS, iterative. Check with each visited neighbor to see if the nodes are in same set or not.

Search for range in both direction

Recursive. Find connected component id, or the root id. Check whether child(current index) and parent(the value) are the same. If they are, return the

Push list of nested integers to stack in REVERSE order. So that when popping out of stack, it's the correct order.

Insert char to the original input string If the index is even, return # If the index is odd, return char in the original string