LC-Meta Flashcards
Binary tree vertical order traversal
You know it
Add tuple to dictionary;
Pop left from queue
Valid word abbreviation
- Make sure index2 is in range while getting the count
- Check if enough remaining chars in word and early return
Nested list weight sum
Be careful about updating primitive variables with inner function.
lowest common ancestor iii - with parent pointer
Two pointers that can merge, making sure they go through the same distance and eventually merge
lowest common ancestor ii - nodes may or may not exist
Post order
Return (none, 0) as default after checking left and right
Minimum remove to make valid parentheses - return just one valid string
Two pass; maintain balance.
T - N
S - N
Valid Palindrome I
Get lower case of letter lower()
Check if letter is alphanumeric isalnum()
Reverse a string or list
Valid palindrome II - remove at most one letter
Start from head and tail; whenever no match found, try remove either side
Dot product of two sparse vectors
- Get both index and element by using enumerate func
- Get both key and value by items func
- Consider using array instead of hashmap!
Validate palindrome - remove at most K letters
Think about base cases
Memorization
How to infer current from child cases
Random pick with weight
Prefix sum the same length as array
Binary search - if low < target; else; then check both low and high
Random function - random.randint(start, stop) both inclusive
Basic calculator II
- Track current operation
- How to truncate towards 0 when doing division for negative values
- isdigit()
- isspace()
Basic calculator - with parentheses and only addition and subtraction
- In place update result, we still need a stack though - why?
- When operator found, finish previous calculation and reset the sign and operand
- When open parenthesis found, cache the current sign and result in stack. Reset the result and sign
- When closing parenthesis found, finish previous calculation first, pop from stack and complete the calculation outside of the parenthesis. Reset operator.
Lowest common ancestor - two nodes must exist
Do preorder and early return
https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/
Lowest common ancestor of binary search tree
Check the root value against p and a value and move to subproblem on either right or left subtree
What’s the stop case?
Basic calculator III - with positive number s only, parentheses and all operators
- We anyway need to use a stack.
- Check if an variable is integer - isinstance(e, int)
- Use while loop instead of for loop
- How to truncate towards 0 when negative division
- What to do when open and closing parentheses encountered
- Reset current operation when dealing with open parentheses
Building with ocean view
Monotonic stack.
Kth largest element in an array
- initialize heap as list
- heapq.heappush
- heapq.heappop
- heap[0]
- Why do we use minimum heap here? Why do we pop when heap size is larger than k
Range sum of BST
In order traversal - try recursion
Moving average from data stream
Deque
Initialize sum as float(0)
Simplify path
- For dots, check if dots are between slashes
- When dealing with current directly or previous directly, make exception for root directory
Convert binary search tree to sorted doubly linked list
In order traversal
Sum root to leaf numbers
DFS
Simplify path
Remember to verify dots are only between slashes before moving on checking dots numbers
Remember to make exceptions for root directory slash
Insert into sorted circular linked list
- No node
- Single node
- Use two pointers and while loop
- Insert value between max and min
- Find the tail, check if insert value is beyond and min and max range
- When back to the head, just insert
Custom sort string
Frequency dictionary
3 sum closest
Sort.
Enumerate the start
Binary search and try to get closer and maintain the absolute diff.
Return target + diff
K closet points to origin
Heap
Tuple in heap
Interval list intersections
- Two pointers
- Get the start and end first
- Check if the interval is valid
- Move pointers by comparing end of the two intervals
https://leetcode.com/problems/interval-list-intersections/
Sticker to spell word
- DFS on subsequence
- For each subsequence, check which sticker to start with and exhaust the sticker by making a deep copy of it, then DFS on the remaining subsequence
- When starting with different stickers, get what’s the minimum result
- Eventually cache the minimum result for the subsequence
- Apply the DFS on entire subsequence
Word break - check if break is true or false
Start with each word and DFS and see if possible
Word break II - return all sentences that can be formed
Start with word and do DFS, if a solution is found the append to global result;
Pop from current sentence after moving to next word
https://leetcode.com/problems/word-break-ii/description/
Pow(x, n)
Binary expression
Two sum - sorted array, avoid duplicates
Low and high pointers.
3 Sum; K Sum
Enumerate the start and skip duplicates.
Recursively call K-1 sum or 2 sum.
Iterate through the result from K - 1 sum or 2 sum and add to result.
Make a large island
Union find;
Get the maximum size during first pass for building the parent dictionary.
We can return early for some edge cases.
Remember to use a dictionary to record how many islands we can connect given a cell of water.
Number of islands
BSF from each island and add to visited set
Increment the result after BFS is done with the island.
Use set instead of list to store visited islands, because set provides constant search time
Word Ladder
- Get all words combinations
- BSF and maintain number of steps
https://leetcode.com/problems/word-ladder/description/
Min stack
Use one stack. Maintain the minimum value separately
Valid number
- Three variables
- enumerate the string
- e should be after digits and not seen before; e can be right after dots! Reset digit seen because we expect integer after e
- dots can no be seen twice or after e
Shortest path in binary matrix - 8 directional
- BFS
- Edge case
- How to maintain distance for each node?
Subarray sum equals K - total number of subarrays;
Negative number in the array
Prefix sum + dictionary
Sum to to a set of indexes - why?
We actually don’t need to store the set of indexes, we can just have a frequency table.
Continuous subarray sum that is always a multiple of K
Dictionary of residue
Subarray product less than K - all positive numbers
Same direction two pointers;
Enumerate the start; end start from 0.
Remember to check the end - out of range or not, it impacts how we calculate the range.
https://leetcode.com/problems/subarray-product-less-than-k/description/
Group shifted strings
Do mod operation and take the residue and build hash key. In Python it’s guaranteed to return a nonnegative residue.
Python ord(c) to return a number representing the char.
Find Peak Item
Binary search
LRU cache
Double linked list to efficiently perform remove and insert.
- Store the key with the node, so we can remove from the dictionary
- del dictionary[key]
- Define new node class and constructor. Val and key initialized as None
Maximum swap
Digit to highest index
Random pick index
Number to indexes dictionary
Random.randint(start, end) both inclusive
Toeplitz matrix
Optimize the space.
Diameter of binary tree
DFS
Closest binary search tree value
Recursion version, no need to return result from the DFS function. Update the result in place.
Binary tree right side view
https://leetcode.com/problems/binary-tree-right-side-view/description/
BFS by layer
Copy list with random pointer
Dictionary from old to new nodes;
Recursion;
If old in dictionary, directly return the new nodes
Clone graph
Old to new nodes dictionary at class level
Recursion
Product of two run-length encoded arrays
Two pointer
Remember to check if two intervals can be merged in result
Update original two inputs in place
Top K frequent elements
Frequency map and convert to tuple list
Heap sort on the tuple and keep heap size as K
Exclusive time of functions
https://leetcode.com/problems/exclusive-time-of-functions/description/
Maintain current running Id and current time.
Update the current time.
Pop from stack when a function ends
Missing ranges
Edge case when input is empty
Diagonal traversal
Maintain a flag of direction;
Change the head when reaching the boundary
Flip the head
If at the corner, just return
Merge intervals
- Use just one pointer.
- Maintain current start and end
- Iterate through the input and compare with current start and end.
- Pop from result if needed.
Check if an original string exists given two encoded string
- Analysis first character of both strings and recursively solve the problem
- how many possible number combinations? Enumerate them and solve iteratively
- Use memo
https://leetcode.com/problems/check-if-an-original-string-exists-given-two-encoded-strings/
Account merge
BFS
Email to name
Unique emails
Merge K sorted lists
- Merge two sorted
- Override original list1
Merge sorted array
Start from the end - m + n - 1
Meeting room II - how many meeting rooms needed
Maintain a heap of meeting room end time
Return the length of heap
Design tic tax toe
Maintain arrays of the marked blocks for each row and col and diagonal or anti-diagonal.
Set player to either 1 or -1
Each move should update all arrays
Remove invalid parentheses - return all unique valid strings with minimum number of removals
DFS, pass a new str into recursive call
Convert sorted linked into binary search tree 109
Converted linked list to array and the divide and conquer
Maximum consecutive ones
Two window
Be super careful with moving end
After while loop, check both cases - if end is out of bound or not
Kth missing positive number
Index to missing number? Binary search. Follow the standard binary search pattern.
Verifying an alien dictionary
- Use zip
- No need to compare more if first different char is sorted
3 check edge case - all letters the same
class Solution(object):
def isAlienSorted(self, words, order):
“””
:type words: List[str]
:type order: str
:rtype: bool
“””
letter_order = {}
for index, letter in enumerate(order):
letter_order[letter] = index
# apple app
for word1, word2 in zip(words, words[1:]):
for letter1, letter2 in zip(word1, word2):
if letter1 != letter2:
if letter_order[letter1] > letter_order[letter2]:
return False
# if we find the first different character and they are sorted,
# then there's no need to check remaining letters
break
else:
if len(word1) > len(word2):
return False
return True
Populate next right pointer in each node
Make use of perfect binary to optimize the efficient, use while loop to check leftmost pointer at each letter
Add Strings
Pointers from last element and cache carry
All nodes distance K in binary tree
Two rounds of DFS
Build parent pointer
Unique path I and II
Memorization
Merge two BSTs
Use two stacks to do in-order traversal as the same time
https://favtutor.com/blogs/merge-binary-search-trees
Remove Nth node from end of list
Two pointers. Use dummy head!
Check completeness of binary tree
Get total nodes count.
DFS on indexes
Swapping nodes in a single linked list - kth from the beginning and kth from the end
3 pointers.
Front pointer
End pointer
Another current pointer that goes to end
Expression add operators
DFS and backtracking
Index, cur num, pre num, total, string
https://leetcode.com/problems/expression-add-operators/submissions/1285559171/
Next permutation
Find the first non-increasing digit from the last, swap it with the first digit larger than it to its right, and then reverse the sub list to its right
Validate IP address
Validate v4 and v6 separately by checking the number of dots
K smallest elements from n sorted array
Use heap, first push all first elements to heap.
Reverse integer
Keeping dividing and mod
Check against integer range
Minimum add to make parentheses valid
Maintain balance. One pass.
