Keep a window of 3 highest times sentences with a Priority Queue (min heap). Note that the small times go first, then the lexicographically larger one

Just check next.

Recursive. Convert number n < 1000 to English words string. Base cases: If n == 0, 0 is already covered as a single digit. If it's not a single digit,

judge whether a string is a Palindrome

Array, O(n) Time. Iterate through the array and check whether the sum of size size subarray > s. If larger, return true. Otherwise false.

Stack. Using stack to save previous length at each level. Find current level by the last index of "\t" in filename + 1. Compare current level with sta

DP, bottom-up, O(kn) Time, O(kn) Space

DP, bottom-up, O(kn) Time, O(n) Space If k >= n/2, we can have transactions any time, O(n). dp[k][i+1] represents the max profit of using [0, i] and k

Sort. Greedy. O(nlogn) Time. Sort the intervals by start time, ascending. Use a pointer, prev, for previous merged interval. For each of the intervals

DP Keep track of previous minimum possible value and k while iterating over the array If A[i] <= prev - k, which means k is not big enough, calculate

Modification of

Remove node from list and add it to head.

Dijkstra's Algorithm. Generate minimum distances from node K to each node possible. Then the maximum is the time needed. Similar to BFS, except that i

Bellman Ford.

Dijkstra. Optimized getEdges to O(1).

Binary Search. Note that letters are sorted but can have DUPLICATES!

Binary Search. Find the next letter of target in the array. Can be faster since we can return as soon as the letter is found.

Binary Search. Same idea. But use modular operation at the end. Since left is within [0, letters.length]. left = letters.length when the target is alw

Backtracking

a^k % 1337 = (a % 1337)^k % 1337

Return the ranking position of k in nums.

Remove a node from double linked list.

Last digit is zero, output? Reversed might overflow? 1000000003

O(1) Time, O(1) Space Move res 1 bit left, a Get first bit of n, b res = a ^ b Move n right 1 bit for next loop Unsigned shift means fill new bit at t

O(1) Time, O(1) Space Divide 32 bits into 4 bytes Cache each byte and its reversed result in a hashmap Check cache for result first instead of computi

Merge. O(m + n). The indices are already sorted in the list. To get shortest distance, just move the pointer with smaller value. For i < indices1.size

Swap two numbers without using a temporary variable

What changed to the original solution if one of the numbers can reused once? 1. When i is set, j can start from i instead of i + 1. 2. During two sum,

O(log5-n)

Hash Table. One-pass. O(n) Time. O(n) Space. As we traverse through the array, we may save what we've traversed to check if there is a number that can

1) Initialize index as index+1. 2) Do following while index is smaller than or equal to n. ...a) Add value to BITree[index] ...b) Go to parent of BITr

DP. Bottom-up. Build a boolean array of size n+1 for break results at different lengths. Recurrence: dp[i] = dp[j] && dict.contains(s.substring(j, i))

Union-Find. Each person is a connected component. Each email is just a graph node. Generate an ID for each email, since email is the key to decide whe

DFS. Build a graph to connect adjacent emails together. Traverse the graph. If the email is not visited, dfs to get all emails. Sort and add the name.

Union-Find with a separate class.

Math. String. Initialize two pointers i and j at the end of a and b. Use one integer c for the carry. While i >= 0 or j >= 0 or c == 1: | Add char in

Math. String. From end to start, do it digit-by-digit. Get current digits of ab and b, add them up. Also use an integer to store carry from the previo

Math. We may separate the string with '.'. Then we will have the left and right parts. First deal with right part, adding from right to left. The shor

Add a word reversely to Trie. This makes suffix search possible. In addition, we add the words index to the node if word[0,i] is a palindrome. So duri

Use map<String, Integer> Integer is initialized as the index, updated to -1 when the word is added to map to make sure that no duplicate situation hap

O(n) Time, O(n) Space. Keep track of collisions using a Stack (represented by Deque in Java). For each asteroid, ast: | If stack is not empty, asteroi

Stop when k is 0, meaning that all k numbers are picked. | Add combination to result. For each i from start to n: | Add i to current combination that

Stop condition: n is 1, return. If have at least two factors, dereference and add to result. Visit: For each i from start to sqrt(n): | If n is divisi

Backtracking. DFS. Traverse a each node of a subset tree. For each number n in the nums array: | If n is a duplicate of previous number, skip. | Pick

Backtracking. Generate combinations position by position. Get current position's possible letters. Append to the combination so far. Pass the subset a

This BFS is unlike word ladder 1, which we only care about the path length. This one cares about the graph structure, so we connect a string with it's

BFS. Set the starting grid to '0' to mark it as visited. Enqueue to start BFS. While queue is not empty: Get a grid from the queue. Add it's 4-adjacen

Topological Sort. BFS. Start from all nodes with 0 in-degree, which means no prerequisites. While queue is not empty: | Dequeue the next node, add it

In-order traversal, iteratively. Left is previous. Right is next. In-order traverse the binary tree to create the linked list. When traversing a node,

Recursive. Recurrence relation: The final list is the connection of left subtree's list, root and right subtree's list. Base case: If a root is null,

Recursive. Pre-order traversal. Append current node's val and a delimiter. Then recurse down to left and right subtrees. Base case: If node is null, a

Poll a value string from the queue. If null node, return null. Create a tree node with value. Then build left and right subtrees recursively. Return t