Blind 75

Use a hashmap to store complements and return indices when found.

Track running minimum price and maximum profit in one pass.

Use a HashSet to detect duplicates quickly.

Use Kadane's algorithm: track max ending here and global max.

Compute prefix and suffix products to avoid division.

Track both max and min products at each position, swapping when encountering negatives to handle sign flips.

Use binary search comparing mid with right boundary to determine which half contains the minimum.

Identify which half is sorted, then determine if target lies in that sorted half to decide search direction.

Sort and use two pointers to find triplets summing to zero, skipping duplicates.

Two-pointer: move the shorter line inward to try larger area.

Add two integers using bitwise operations without using + or - operators.

Count the number of set bits (1s) in the binary representation of an integer.

Return array where result[i] is the number of 1 bits in binary representation of i.

Find the missing number in array containing n distinct numbers from 0 to n.

Reverse the bits of a 32-bit unsigned integer.

Count distinct ways to climb n stairs when you can take 1 or 2 steps at a time.

Find minimum coins needed to make amount using unbounded knapsack DP.

Find length of longest strictly increasing subsequence using binary search on tails array.

Find longest common subsequence between two strings using 2D DP table.

Check if string can be segmented into dictionary words using DP.

Count number of combinations that sum to target where order matters (permutations).

Count unique paths from top-left to bottom-right in m×n grid moving only right/down.

Determine if you can reach last index by tracking furthest reachable position greedily.

Deep clone undirected graph using DFS/BFS with HashMap to track old→new node mapping.

Detect if course prerequisites form a cycle using topological sort or DFS cycle detection.

Find cells that can flow to both oceans by doing reverse DFS from ocean borders.

Use DFS/BFS to flood-fill islands and count connected components.

Use HashSet to find sequence starts (no n-1) and count consecutive numbers in O(n).

Build graph from word order relationships and return topological sort of character ordering.

Check if graph is a valid tree: must be connected and have exactly n-1 edges (no cycles).

Convert tree to string and back using BFS level-order or DFS pre-order traversal.

Recursively swap left and right children of every node.

Return max depth using DFS: 1 + max of left and right subtree depths.

Track max diameter as sum of left and right heights at each node during DFS.

Check if tree is height-balanced: at every node, left and right heights differ by at most 1.

Recursively check if two trees have identical structure and node values.

Check if subRoot is identical to any subtree of root using isSameTree helper.

Use BST property: if p and q split at node (one left, one right), that node is LCA.

Use BFS with queue to traverse tree level by level, collecting nodes at each level.

Use BFS to traverse level by level, collecting the rightmost node at each level.

DFS tracking max value on path; count nodes where node.val >= maxSoFar.

DFS with min/max bounds: left subtree < node < right subtree, recursively validate.

Inorder traversal of BST gives sorted order; return kth element encountered.

Use preorder's first element as root, find it in inorder to split left/right subtrees recursively.

Track global max while DFS returns max single-path sum from each node.

Build tree where each node has 26 children (a-z) and boolean flag for word endings.

Implement Trie with wildcard search using DFS to try all branches when '.' encountered.

Build Trie from words, then DFS on board checking Trie nodes to find all matching words.

Use min-heap to always extract smallest element from k lists, adding next element from same list.

Use dummy node and two pointers to build merged list by comparing and advancing smaller node.

Find middle, reverse second half, then merge alternating nodes from both halves.

Use two pointers with n-gap to find node before target, then skip target node.

Use Floyd's cycle detection: slow and fast pointers, if they meet there's a cycle.

Iteratively reverse pointers: track prev, current, and next nodes.

Use Floyd's algorithm: detect cycle, then find entry point by resetting one pointer to head.

Use HashMap + doubly linked list: map for O(1) access, DLL for O(1) eviction of LRU.

Use two stacks: one for values, one tracking minimum at each level.

Use stack to match closing brackets with their corresponding opening brackets.

Backtrack to generate valid combinations: add '(' if open < n, add ')' if close < open.

Use monotonic decreasing stack to track indices, pop when warmer day found.

Sort cars by position, calculate time to target, use stack to count fleets (slower cars create new fleets).

Use stack: push numbers, pop two operands on operator, compute and push result.

Use two stacks: push to stack1, pop/peek from stack2 (transfer when stack2 empty).

Use one queue: on push, add element then rotate queue size-1 times to move it to front.

Use HashMap for follows/tweets, merge k sorted lists with heap for news feed.

Use two heaps: max-heap for smaller half, min-heap for larger half, balance sizes for O(1) median.

Maintain min-heap of size k; top element is always kth largest.

Count frequencies with HashMap, use min-heap of size k to track top k elements.

Use max-heap of size k tracking distances; maintain k closest points by comparing squared distances.

Sort intervals by start time, check if any meeting starts before previous ends.

Sort by start time, use min-heap to track room end times, reuse rooms when available.

Sort by end time, greedily keep intervals that end earliest to minimize removals.

Add non-overlapping intervals before newInterval, merge overlapping ones, add remaining intervals.

Sort intervals by start time, merge overlapping ones by extending end time.

Use write pointer to compact non-zero elements, then fill remaining positions with zeros.