DSA on Chirag Hasija

Best Time to Buy and Sell Stock

Mon, 01 Jan 0001 00:00:00 +0000

Example

prices = [7, 1, 5, 3, 6, 4]

Output: 5

Buy on day 1 (price = 1) and sell on day 4 (price = 6) for a profit of 6 - 1 = 5.

Why this works

You must buy before you sell, so scan left to right. At every position, the best you can do is sell at today’s price after buying at the cheapest price you’ve seen so far. By tracking the running minimum, you compute the optimal profit in a single pass.

Binary Tree Level Order Traversal

Mon, 01 Jan 0001 00:00:00 +0000

Example

Output: [[3], [9, 20], [15, 7]]

Level 0 has just the root 3. Level 1 has 9 and 20 (left to right). Level 2 has 15 and 7.

Why this works

BFS naturally visits nodes level by level. The key trick is snapshotting the queue size at the start of each level — that tells you exactly how many nodes belong to the current depth. You process that many nodes, and any children you add during this pass belong to the next level.

Climbing Stairs

Mon, 01 Jan 0001 00:00:00 +0000

Example

n = 5

Output: 8

There are 8 distinct ways to climb 5 stairs using 1- or 2-steps: [1,1,1,1,1], [2,1,1,1], [1,2,1,1], [1,1,2,1], [1,1,1,2], [2,2,1], [2,1,2], [1,2,2].

Why this works

To reach step n, you must have come from either step n-1 (took 1 step) or step n-2 (took 2 steps). So the number of ways to reach step n is the sum of ways to reach those two previous steps. This is exactly the Fibonacci sequence, and you only need two variables instead of a full array.

Clone Graph

Mon, 01 Jan 0001 00:00:00 +0000

Example

Graph: 1 -- 2 -- 3 -- 1 (a triangle where 1 connects to 2 and 3, and 2 connects to 3)

Output: A new graph with the same structure – node 1’ connects to 2’ and 3’, node 2’ connects to 1’ and 3’, node 3’ connects to 1’ and 2’. All nodes are new objects, not references to the originals.

Why this works

You need to create a copy of every node and replicate every edge, without getting stuck in cycles. The hashmap serves two purposes: it tracks which nodes have already been cloned (preventing infinite loops), and it lets you look up any node’s clone in O(1) when wiring up neighbor connections.

Coin Change

Mon, 01 Jan 0001 00:00:00 +0000

Example

coins = [1, 3, 4], amount = 6

Output: 2

Because 3 + 3 = 6, which uses only 2 coins. Other combinations like 4 + 1 + 1 use 3 coins, and 1 + 1 + 1 + 1 + 1 + 1 uses 6.

Why this works

To make amount i with the fewest coins, you can try adding one coin of each denomination to the best solution for i - coin. By building up from amount 0, every smaller sub-problem is already solved when you need it, so you always pick the true minimum.

Combination Sum

Mon, 01 Jan 0001 00:00:00 +0000

Example

candidates = [2, 3, 6, 7], target = 7

Output: [[2, 2, 3], [7]]

Two combinations sum to 7: 2 + 2 + 3 = 7 and 7 = 7. Each candidate can be reused, so using 2 twice is allowed.

Why this works

You explore all possible combinations by trying each candidate and recursing with the updated total. Since candidates can be reused, the recursive call passes the same index i (not i+1). The start index prevents going backward, which eliminates duplicate orderings like [2,3] vs [3,2].

Construct Binary Tree from Preorder and Inorder Traversal

Mon, 01 Jan 0001 00:00:00 +0000

Example

preorder = [3, 9, 20, 15, 7], inorder = [9, 3, 15, 20, 7]

Output:

Both traversals describe the same tree. The preorder tells us 3 is the root, and the inorder tells us 9 is in the left subtree while 20, 15, 7 are in the right subtree.

Why this works

Preorder traversal visits the root first, then left subtree, then right subtree. Inorder traversal visits left subtree, then root, then right subtree. So the first element in preorder tells you the root, and finding that root in inorder tells you how to split elements into “left subtree” and “right subtree” groups. Recursing on each group builds the full tree.

Container With Most Water

Mon, 01 Jan 0001 00:00:00 +0000

Example

height = [1, 8, 6, 2, 5, 4, 8, 3, 7]

Output: 49

The lines at index 1 (height 8) and index 8 (height 7) form the largest container. The water height is limited by the shorter line (7), and the width is 8 - 1 = 7, giving area 7 * 7 = 49.

Why this works

Area = min(height[left], height[right]) * width. Starting with maximum width (pointers at both ends), you greedily move the shorter pointer inward. Moving the taller pointer can never increase the area because the bottleneck is the shorter side and the width is shrinking.

Contains Duplicate

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [1, 2, 3, 1]

Output: true

The value 1 appears at both index 0 and index 3, so the array contains a duplicate.

Why this works

A hash set gives you O(1) lookups. As you walk through the array, you check whether each number has been seen before. The moment you find one that has, you know there is a duplicate – no need to check the rest.

Course Schedule

Mon, 01 Jan 0001 00:00:00 +0000

Example

numCourses = 4, prerequisites = [[1,0],[2,1],[3,2]]

Output: true

Course 0 has no prerequisites, course 1 requires 0, course 2 requires 1, and course 3 requires 2. Taking them in order 0 -> 1 -> 2 -> 3 satisfies all prerequisites with no circular dependencies.

Why this works

Course prerequisites form a directed graph. If there is a cycle (A requires B, B requires C, C requires A), those courses can never be completed. Kahn’s algorithm detects cycles by peeling off nodes with no incoming edges layer by layer. If every node gets peeled off, there is no cycle and all courses are completable.

Daily Temperatures

Mon, 01 Jan 0001 00:00:00 +0000

Example

temperatures = [73, 74, 75, 71, 69, 72, 76, 73]

Output: [1, 1, 4, 2, 1, 1, 0, 0]

Day 0 (73) waits 1 day for 74. Day 2 (75) waits 4 days for 76. Day 3 (71) waits 2 days for 72. Days 6 and 7 have no warmer future day, so they get 0.

Why this works

A monotonic decreasing stack keeps track of days that haven’t found a warmer day yet. When a new warmer temperature comes along, it resolves all the cooler days sitting on the stack. Each index is pushed and popped at most once, so the total work is O(n) despite the nested loop.

Decode Ways

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "226"

Output: 3

The three valid decodings are: "2|2|6" = BBF, "22|6" = VF, and "2|26" = BZ. Each split uses only valid letter mappings (1-26).

Why this works

At each position you have at most two choices: decode the current digit as one letter (1-9 maps to A-I), or decode the current and previous digit together as one letter (10-26 maps to J-Z). The total decodings at position i is the sum of decodings from both valid choices. Zeros can only appear as part of a two-digit code (10 or 20), never alone.

Evaluate Reverse Polish Notation

Mon, 01 Jan 0001 00:00:00 +0000

Example

tokens = ["2", "1", "+", "3", "*"]

Output: 9

In standard notation this is (2 + 1) * 3 = 9. The + applies to 2 and 1 giving 3, then the * applies to that 3 and 3 giving 9.

Why this works

Reverse Polish Notation puts operators after their operands, so you never need parentheses or precedence rules. A stack naturally collects operands. When you hit an operator, the two most recent operands are right on top of the stack, ready to be combined.

Find Minimum in Rotated Sorted Array

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [3, 4, 5, 1, 2]

Output: 1

The original sorted array [1, 2, 3, 4, 5] was rotated 3 times to produce [3, 4, 5, 1, 2]. The minimum element is still 1.

Why this works

In a rotated sorted array, the minimum is at the “rotation point” where the values drop. Comparing nums[mid] to nums[right] tells you which side the drop is on. If mid is larger than right, the drop (and minimum) must be somewhere to the right. Otherwise, the minimum is at mid or to its left.

Group Anagrams

Mon, 01 Jan 0001 00:00:00 +0000

Example

strs = ["eat", "tea", "tan", "ate", "nat", "bat"]

Output: [["eat", "tea", "ate"], ["tan", "nat"], ["bat"]]

“eat”, “tea”, and “ate” are anagrams of each other (same letters rearranged). “tan” and “nat” are anagrams. “bat” has no anagram partner in the list.

Why this works

All anagrams are made of the exact same letters, just rearranged. If you sort each string alphabetically, anagrams collapse into the same string. Use that sorted string as a hashmap key to group them together.

House Robber

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [2, 7, 9, 3, 1]

Output: 12

Rob houses 0, 2, and 4 for a total of 2 + 9 + 1 = 12. No two of these houses are adjacent, and no other combination yields more.

Why this works

You can never rob two adjacent houses, so at each house you face a simple choice: rob it (adding its value to the best you could do two houses ago) or skip it (keeping the best from the previous house). By carrying forward just the last two best totals, you always have enough information to make the optimal decision.

Insert Interval

Mon, 01 Jan 0001 00:00:00 +0000

Example

intervals = [[1,3], [6,9]], newInterval = [2,5]

Output: [[1,5], [6,9]]

The new interval [2,5] overlaps with [1,3] (since 2 falls within 1-3), so they merge into [1,5]. The interval [6,9] does not overlap and stays unchanged.

Why this works

Since the existing intervals are already sorted, you can process them in one pass with three distinct phases: intervals entirely before the new one, intervals overlapping with the new one (which get merged together), and intervals entirely after. This avoids re-sorting and handles all edge cases cleanly.

Invert Binary Tree

Mon, 01 Jan 0001 00:00:00 +0000

Example

Input:        4              Output:       4
            /   \                        /   \
           2     7                      7     2
          / \   / \                    / \   / \
         1   3 6   9                  9   6 3   1

Every node’s left and right children are swapped, producing a mirror image of the original tree.

Why this works

Every node in a mirrored tree has its left and right children swapped compared to the original. By swapping children at each node and recursing downward, every level of the tree gets mirrored. The recursion naturally handles all depths because each subtree is itself a smaller tree to invert.

Koko Eating Bananas

Mon, 01 Jan 0001 00:00:00 +0000

Example

piles = [3, 6, 7, 11], h = 8

Output: 4

At speed 4, Koko takes 1 hour for pile 3, 2 hours for pile 6, 2 hours for pile 7, and 3 hours for pile 11 – totaling 8 hours, which exactly fits. Speed 3 would require 10 hours, which exceeds the limit.

Why this works

Instead of searching through data, you are searching through possible answers (eating speeds 1 to max pile size). For each candidate speed, you can calculate exactly how many hours it takes. Since “can finish in time” flips from false to true at some speed, binary search finds that threshold efficiently.

Kth Smallest Element in a BST

Mon, 01 Jan 0001 00:00:00 +0000

Example

k = 3

Output: 3

The values in sorted order are [1, 2, 3, 4, 5, 6]. The 3rd smallest is 3.

Why this works

Inorder traversal of a BST always produces values in sorted ascending order (left, root, right). So the 1st node visited is the smallest, the 2nd is the next smallest, and so on. By counting visits and stopping at k, you find the kth smallest without sorting anything.

Linked List Cycle

Mon, 01 Jan 0001 00:00:00 +0000

Example

head = [3, 2, 0, -4] where the tail (-4) connects back to node with value 2

Output: true

After reaching -4, the next pointer leads back to 2 instead of null, forming a loop: 2 -> 0 -> -4 -> 2 -> .... Since the list never ends, it has a cycle.

Why this works

Think of two runners on a circular track: the faster one will always lap the slower one. If the linked list has a cycle, the fast pointer (2 steps) will eventually catch up to the slow pointer (1 step) from behind. If there is no cycle, the fast pointer simply reaches the end.

Longest Increasing Subsequence

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [10, 9, 2, 5, 3, 7, 101, 18]

Output: 4

One longest increasing subsequence is [2, 3, 7, 101]. Another is [2, 5, 7, 101] or [2, 3, 7, 18]. All have length 4, and no strictly increasing subsequence of length 5 exists.

Why this works

For each element, you ask: “What is the longest increasing subsequence I can build that ends right here?” You check every previous element – if it is smaller, you could append the current element to that subsequence. Taking the maximum across all such extensions gives the best answer at each position.

Longest Repeating Character Replacement

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "AABABBA", k = 1

Output: 4

The substring "AABA" (indices 0-3) has 3 A’s and 1 B. Replacing that single B with A gives "AAAA", a string of 4 repeating characters, using exactly 1 replacement.

Why this works

In any window, you only need to replace the characters that are NOT the most frequent one. So the number of replacements needed is (window size - count of most frequent character). If that exceeds k, the window is too big and you shrink from the left. This lets you find the longest valid window in one pass.

Longest Substring Without Repeating Characters

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "abcabcbb"

Output: 3

The longest substring without any repeating characters is "abc", which has length 3. Other valid substrings like "bca" or "cab" also have length 3, but none longer exists without a repeated character.

Why this works

A sliding window lets you efficiently explore all substrings without repeating characters. Expand the right side to grow the window; when a duplicate appears, shrink from the left until it is gone. The set tracks what is currently in the window, giving O(1) duplicate checks.

LRU Cache

Mon, 01 Jan 0001 00:00:00 +0000

Example

capacity = 2

put(1, 1), put(2, 2), get(1) returns 1, put(3, 3), get(2) returns -1, put(4, 4), get(1) returns -1, get(3) returns 3, get(4) returns 4

After put(1,1) and put(2,2), the cache is full. get(1) returns 1 and marks key 1 as recently used. When put(3,3) is called, key 2 is evicted because it was used least recently, so get(2) returns -1. When put(4,4) is called, key 1 is evicted, so get(1) returns -1 while keys 3 and 4 are still accessible.

Maximum Depth of Binary Tree

Mon, 01 Jan 0001 00:00:00 +0000

Example

Output: 3

The longest path from root to leaf is 3 → 20 → 15 (or 3 → 20 → 7), which passes through 3 nodes.

Why this works

The depth of any node equals 1 (for itself) plus the depth of its deepest child. By recursing to the leaves where null returns 0, each call naturally computes the height of its subtree and passes it back up. The root ends up with the maximum depth of the entire tree.

Merge Intervals

Mon, 01 Jan 0001 00:00:00 +0000

Example

intervals = [[1,3], [2,6], [8,10], [15,18]]

Output: [[1,6], [8,10], [15,18]]

Intervals [1,3] and [2,6] overlap (they share the range 2-3), so they merge into [1,6]. The remaining intervals [8,10] and [15,18] don’t overlap with anything, so they stay as-is.

Why this works

Once intervals are sorted by start time, any overlapping intervals must be next to each other. You walk through the sorted list and either extend the current merged interval (if there is overlap) or start a new one (if there is a gap). This single pass handles all possible overlaps including chains of multiple intervals merging together.

Merge K Sorted Lists

Mon, 01 Jan 0001 00:00:00 +0000

Example

lists = [[1, 4, 5], [1, 3, 4], [2, 6]]

Output: [1, 1, 2, 3, 4, 4, 5, 6]

All three sorted lists are combined into a single sorted list. Every element from every input list appears exactly once in the output, in non-decreasing order.

Why this works

You need the smallest element across k lists at each step. Comparing all k heads every time would be slow. A min-heap keeps the k heads organized so you can extract the minimum in O(log k) time instead of O(k), making the overall algorithm much faster.

Merge Two Sorted Lists

Mon, 01 Jan 0001 00:00:00 +0000

Example

list1 = [1, 3, 5], list2 = [2, 4, 6]

Output: [1, 2, 3, 4, 5, 6]

Both lists are already sorted individually. The merged result contains all elements from both lists arranged in non-decreasing order.

Why this works

Both input lists are already sorted. At each step, you just compare the two front elements and take the smaller one. This is the same idea as the “merge” step in merge sort. By always choosing the smallest available node, the result list stays sorted.

Min Stack

Mon, 01 Jan 0001 00:00:00 +0000

Example

Operations: push(-2), push(0), push(-3), getMin(), pop(), top(), getMin()

push(-2), push(0), push(-3) – stack now contains [-2, 0, -3]
getMin() returns -3 – the smallest value currently in the stack
pop() removes -3 from the top
top() returns 0 – the new top element
getMin() returns -2 – with -3 removed, -2 is now the smallest

Why this works

The trick is that the minimum can only change when you push or pop. By maintaining a second stack where each entry records “what is the minimum at this depth?”, you always know the current minimum by peeking at the top. When you pop, the previous minimum is automatically restored.

Minimum Window Substring

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "ADOBECODEBANC", t = "ABC"

Output: "BANC"

The substring "BANC" (positions 9-12) is the shortest substring of s that contains all three characters A, B, and C from t. Other valid windows like "ADOBEC" also contain all of them, but "BANC" is shorter at length 4.

Why this works

You need the smallest window in s that contains every character from t. Expand the window rightward until it contains all required characters, then shrink from the left to minimize it. The “formed” counter tracks how many unique characters have met their required count, so you know exactly when the window is valid.

Non-overlapping Intervals

Mon, 01 Jan 0001 00:00:00 +0000

Example

intervals = [[1,2], [2,3], [3,4], [1,3]]

Output: 1

Removing just [1,3] is enough to make the remaining intervals [1,2], [2,3], and [3,4] non-overlapping. The interval [1,3] overlaps with both [1,2] and [2,3], so removing it solves all conflicts at once.

Why this works

Sorting by end time is the key insight. By always keeping the interval that ends earliest, you leave the maximum room for future intervals. Any interval that overlaps with a kept interval must be removed – and since we chose the earliest-ending one, we are guaranteed to minimize total removals. This is a classic greedy activity selection approach.

Number of Islands

Mon, 01 Jan 0001 00:00:00 +0000

Example

grid = [
  ["1","1","0","0"],
  ["1","0","0","1"],
  ["0","0","1","1"]
]

Output: 2

There are two separate groups of connected land cells. The first island consists of the three 1s in the upper-left corner, and the second island consists of the three 1s in the lower-right area. They are separated by water and not connected horizontally or vertically.

Why this works

Each island is a connected group of ‘1’ cells. When you find an unvisited ‘1’, you know it is a new island. By flood-filling (DFS) from that cell and turning every connected ‘1’ into ‘0’, you “sink” the entire island so it will not be counted again. The total number of flood-fills you trigger equals the number of islands.

Pacific Atlantic Water Flow

Mon, 01 Jan 0001 00:00:00 +0000

Example

heights = [
  [1, 2, 2, 3, 5],
  [3, 2, 3, 4, 4],
  [2, 4, 5, 3, 1],
  [6, 7, 1, 4, 5],
  [5, 1, 1, 2, 4]
]

Output: [[0,4], [1,3], [1,4], [2,2], [3,0], [3,1], [4,0]]

For example, cell (2,2) with height 5 can reach the Pacific (top/left edges) because water flows downhill through cells to the top or left, and can also reach the Atlantic (bottom/right edges) through cells to the bottom or right. Only these 7 cells can drain to both oceans.

Permutations

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [1, 2, 3]

Output: [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]

There are 3! = 6 ways to arrange three distinct numbers. Each permutation uses every element exactly once in a different order.

Why this works

A permutation uses every element exactly once in some order. At each position, you try placing each unused element, then recurse to fill the remaining positions. The used set prevents picking the same element twice. When all positions are filled, you have a complete permutation.

Product of Array Except Self

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [1, 2, 3, 4]

Output: [24, 12, 8, 6]

Each position holds the product of all other elements: result[0] = 2 * 3 * 4 = 24, result[1] = 1 * 3 * 4 = 12, result[2] = 1 * 2 * 4 = 8, result[3] = 1 * 2 * 3 = 6.

Why this works

The product of all elements except index i equals (product of everything left of i) times (product of everything right of i). You can compute both with two simple passes, avoiding division entirely. The first pass builds left-products, and the second pass multiplies in right-products.

Remove Nth Node From End of List

Mon, 01 Jan 0001 00:00:00 +0000

Example

head = [1, 2, 3, 4, 5], n = 2

Output: [1, 2, 3, 5]

The 2nd node from the end is 4. Removing it leaves the list as 1 → 2 → 3 → 5.

Why this works

If you put two pointers n+1 apart and slide them together, when the front pointer falls off the end, the back pointer is exactly one node before the one you want to remove. This finds the nth-from-end in a single pass without needing to know the list length.

Reverse Linked List

Mon, 01 Jan 0001 00:00:00 +0000

Example

head = [1, 2, 3, 4, 5]

Output: [5, 4, 3, 2, 1]

The original list 1 → 2 → 3 → 4 → 5 is reversed so that every link points in the opposite direction, producing 5 → 4 → 3 → 2 → 1.

Why this works

Each node in a linked list points to the next node. To reverse the list, you just need to make every node point to the previous node instead. By walking through one node at a time and flipping pointers as you go, you reverse the entire chain in a single pass.

Same Tree

Mon, 01 Jan 0001 00:00:00 +0000

Example

Tree p:     1        Tree q:     1
           / \                  / \
          2   3                2   3

Output: true

Both trees have the same structure (root with two children) and identical values at every position: root is 1, left child is 2, right child is 3.

Why this works

Two trees are identical only if every corresponding pair of nodes has the same value and the same structure. By checking three conditions at each step — both null, one null, or values differ — you catch every possible mismatch. Recursion handles the rest by drilling into left and right subtrees simultaneously.

Search in Rotated Sorted Array

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [4, 5, 6, 7, 0, 1, 2], target = 0

Output: 4

The original sorted array [0, 1, 2, 4, 5, 6, 7] was rotated at the pivot, becoming [4, 5, 6, 7, 0, 1, 2]. The target value 0 is at index 4.

Why this works

In a rotated sorted array, at least one half (left or right of mid) is always properly sorted. You can check if the target falls within the sorted half’s range. If it does, search there; otherwise, search the other half. This preserves the O(log n) binary search guarantee.

Spiral Matrix

Mon, 01 Jan 0001 00:00:00 +0000

Example

Matrix:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

Output: [1, 2, 3, 6, 9, 8, 7, 4, 5]

Reading the matrix in spiral order means: go right along the top row (1, 2, 3), then down the right column (6, 9), then left along the bottom row (8, 7), then up the left column (4), and finally the center element (5).

Why this works

Instead of tracking visited cells, you maintain four boundaries that define the unvisited rectangle. Each spiral pass peels off one layer: right across the top, down the right side, left across the bottom, up the left side. After each direction, the corresponding boundary shrinks inward. The boundary checks prevent double-counting rows or columns in non-square matrices.

Subsets

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [1, 2, 3]

Output: [[], [1], [1,2], [1,2,3], [1,3], [2], [2,3], [3]]

The power set contains all 2^3 = 8 possible subsets, from the empty set to the full set. Each element is either included or excluded, and no two subsets are the same.

Why this works

Every subset is a sequence of include/exclude decisions for each element. By recording the current path at every level of recursion (not just at the leaves), you capture subsets of all sizes. The start index ensures each element only appears after the ones before it, preventing duplicates like {1,2} and {2,1}.

Top K Frequent Elements

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [1, 1, 1, 2, 2, 3], k = 2

Output: [1, 2]

The number 1 appears 3 times and 2 appears 2 times, making them the two most frequent elements. The number 3 only appears once, so it is not included.

Why this works

You need the top k elements by frequency, but sorting costs O(n log n). Instead, use bucket sort: create an array where position i holds numbers that appear i times. Since no number can appear more than n times, you just walk backwards from the last bucket to grab the most frequent elements first.

Two Sum

Mon, 01 Jan 0001 00:00:00 +0000

Example

nums = [2, 7, 11, 15], target = 9

Output: [0, 1]

Because nums[0] + nums[1] = 2 + 7 = 9.

Why this works

For each number, you need to find if its “partner” (target minus current) exists. Instead of scanning the whole array each time (O(n^2)), store every number you’ve seen in a hashmap. This lets you check for the partner in O(1).

Step by step

Walk through the array — for each number, compute what value you’d need to reach the target.
Check the hashmap — if that complement value has been seen before, you found your answer.
Store and move on — if not found, record the current number and its index for future lookups.

Unique Paths

Mon, 01 Jan 0001 00:00:00 +0000

Example

m = 3, n = 3 (3x3 grid)

Output: 6

The robot must move right exactly 2 times and down exactly 2 times to go from the top-left to the bottom-right. The 6 paths correspond to the 6 different orderings of these 4 moves (e.g., RRDD, RDRD, RDDR, DRRD, DRDR, DDRR).

Why this works

You can only move right or down, so the number of ways to reach any cell equals the ways to reach the cell above it plus the ways to reach the cell to its left. The top row and left column each have exactly one path (all-right or all-down), which gives you the base cases to build from.

Valid Anagram

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "anagram", t = "nagaram"

Output: true

Both strings contain exactly the same letters with the same frequencies: three as, one n, one g, one r, and one m. Since t is just a rearrangement of s, it is a valid anagram.

Why this works

Two strings are anagrams if they use exactly the same letters the same number of times. By incrementing a counter for each character in s and decrementing for each character in t, you end up with all zeros only when the frequencies match perfectly.

Valid Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "A man, a plan, a canal: Panama"

Output: true

After removing non-alphanumeric characters and converting to lowercase, the string becomes "amanaplanacanalpanama", which reads the same forwards and backwards.

Why this works

A palindrome reads the same forwards and backwards. Instead of creating a cleaned copy of the string, use two pointers from each end, skipping non-alphanumeric characters and comparing in lowercase. If every pair matches, it is a palindrome.

Valid Parentheses

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "{[()]}"

Output: true

Every opening bracket has a matching closing bracket in the correct order: ( is closed by ), [ is closed by ], and { is closed by }.

Why this works

Brackets must close in the reverse order they open – the most recent opener must be closed first. A stack naturally enforces this “last-in, first-out” order. Every time you see a closing bracket, you check that the top of the stack is the correct matching opener.

Validate Binary Search Tree

Mon, 01 Jan 0001 00:00:00 +0000

Example

Output: false

Node 4 is in the right subtree of 5, but 4 < 5. In a valid BST, every node in the right subtree must be greater than the root. Even though 4 < 7 satisfies the local parent-child rule, it violates the global BST property.

Why this works

A BST is not just “left child < parent < right child” at each node — every node in the left subtree must be less than the root, and every node in the right subtree must be greater. By passing an allowed range (low, high) down the recursion and tightening it at each step, you enforce this global constraint without needing to look back up the tree.

Word Break

Mon, 01 Jan 0001 00:00:00 +0000

Example

s = "leetcode", wordDict = ["leet", "code"]

Output: true

The string can be segmented as "leet" + "code", and both words are in the dictionary.

Why this works

Instead of trying every possible way to split the string (exponential), you build up answers left to right. If you know that the first j characters can be split into valid words, and the substring from j to i is also a dictionary word, then the first i characters can be split too. This avoids re-solving the same sub-problems.