NeetCode 150

Arrays & Hashing

●​ Contains Duplicate​

●​ Valid Anagram​

●​ Two Sum​

●​ Group Anagrams​

●​ Top K Frequent Elements​

●​ Encode and Decode Strings​

●​ Product of Array Except Self​

●​ Valid Sudoku​

●​ Longest Consecutive Sequence​

Two Pointers
●​ Valid Palindrome​

●​ Two Sum II Input Array Is Sorted​

●​ 3Sum​

●​ Container With Most Water​

●​ Trapping Rain Water​

Sliding Window
●​ Best Time to Buy And Sell Stock​

●​ Longest Substring Without Repeating Characters​

 ●​ Longest Repeating Character Replacement​

●​ Permutation In String​

●​ Minimum Window Substring​

●​ Sliding Window Maximum​

Stack
●​ Valid Parentheses​

●​ Min Stack​

●​ Evaluate Reverse Polish Notation​

●​ Generate Parentheses​

●​ Daily Temperatures​

●​ Car Fleet​

●​ Largest Rectangle In Histogram​

Binary Search
●​ Binary Search​

●​ Search a 2D Matrix​

●​ Koko Eating Bananas​

●​ Find Minimum In Rotated Sorted Array​

●​ Search In Rotated Sorted Array​

●​ Time Based Key Value Store​

●​ Median of Two Sorted Arrays​

Linked List
 ●​ Reverse Linked List​

●​ Merge Two Sorted Lists​

●​ Linked List Cycle​

●​ Reorder List​

●​ Remove Nth Node From End of List​

●​ Copy List With Random Pointer​

●​ Add Two Numbers​

●​ Find The Duplicate Number​

●​ LRU Cache​

●​ Merge K Sorted Lists​

●​ Reverse Nodes In K Group​

Trees
●​ Invert Binary Tree​

●​ Maximum Depth of Binary Tree​

●​ Diameter of Binary Tree​

●​ Balanced Binary Tree​

●​ Same Tree​

●​ Subtree of Another Tree​

●​ Lowest Common Ancestor of a Binary Search Tree​

●​ Binary Tree Level Order Traversal​

●​ Binary Tree Right Side View​

●​ Count Good Nodes In Binary Tree​

●​ Validate Binary Search Tree​

 ●​ Kth Smallest Element In a BST​

●​ Construct Binary Tree From Preorder And Inorder Traversal​

●​ Binary Tree Maximum Path Sum​

●​ Serialize And Deserialize Binary Tree​

Heap / Priority Queue

●​ Kth Largest Element In a Stream​

●​ Last Stone Weight​

●​ K Closest Points to Origin​

●​ Kth Largest Element In An Array​

●​ Task Scheduler​

●​ Design Twitter​

●​ Find Median From Data Stream​

Backtracking
●​ Subsets​

●​ Combination Sum​

●​ Combination Sum II​

●​ Permutations​

●​ Subsets II​

●​ Word Search​

●​ Palindrome Partitioning​

●​ Letter Combinations of a Phone Number​

●​ N Queens​
Tries
●​ Implement Trie Prefix Tree​

●​ Design Add And Search Words Data Structure​

●​ Word Search II​

Graphs
●​ Number of Islands​

●​ Max Area of Island​

●​ Clone Graph​

●​ Walls And Gates​

●​ Rotting Oranges​

●​ Pacific Atlantic Water Flow​

●​ Surrounded Regions​

●​ Course Schedule​

●​ Course Schedule II​

●​ Graph Valid Tree​

●​ Number of Connected Components In An Undirected Graph​

●​ Redundant Connection​

●​ Word Ladder​

Advanced Graphs
●​ Network Delay Time​

●​ Reconstruct Itinerary​

●​ Min Cost to Connect All Points​

 ●​ Swim In Rising Water​

●​ Alien Dictionary​

●​ Cheapest Flights Within K Stops​

1-D Dynamic Programming

●​ Climbing Stairs​

●​ Min Cost Climbing Stairs​

●​ House Robber​

●​ House Robber II​

●​ Longest Palindromic Substring​

●​ Palindromic Substrings​

●​ Decode Ways​

●​ Coin Change​

●​ Maximum Product Subarray​

●​ Word Break​

●​ Longest Increasing Subsequence​

●​ Partition Equal Subset Sum​

2-D Dynamic Programming

●​ Unique Paths​

●​ Longest Common Subsequence​

●​ Best Time to Buy And Sell Stock With Cooldown​

●​ Coin Change II​

●​ Target Sum​
 ●​ Interleaving String​

●​ Longest Increasing Path In a Matrix​

●​ Distinct Subsequences​

●​ Edit Distance​

●​ Burst Balloons​

●​ Regular Expression Matching​

Greedy
●​ Maximum Subarray​

●​ Jump Game​

●​ Jump Game II​

●​ Gas Station​

●​ Hand of Straights​

●​ Merge Triplets to Form Target Triplet​

●​ Partition Labels​

●​ Valid Parenthesis String​

Intervals
●​ Insert Interval​

●​ Merge Intervals​

●​ Non Overlapping Intervals​

●​ Meeting Rooms​

●​ Meeting Rooms II​

●​ Minimum Interval to Include Each Query​

Math & Geometry
●​ Rotate Image​

●​ Spiral Matrix​

●​ Set Matrix Zeroes​

●​ Happy Number​

●​ Plus One​

●​ Pow(x, n)​

●​ Multiply Strings​

●​ Detect Squares​

Bit Manipulation
●​ Single Number​

●​ Number of 1 Bits​

●​ Counting Bits​

●​ Reverse Bits​

●​ Missing Number​

●​ Sum of Two Integers​

●​ Reverse Integer
1.Arrays & Hashing
Perfect 👍 ​
We’re now starting Section: Arrays & Hashing​
Let’s go problem by problem, numbered for clear tracking.

🧩 1. Contains Duplicate
📝 Problem Statement
Given an integer array nums, return true if any value appears at least twice in the array,
and return false if every element is distinct.

Example 1:
Input: nums = [1,2,3,1]
Output: true
Explanation: The number 1 appears twice.

Example 2:
Input: nums = [1,2,3,4]
Output: false
Explanation: All elements are distinct.

Example 3:
Input: nums = [1,1,1,3,3,4,3,2,4,2]
Output: true

💡 Intuition
We need to detect if any element repeats.​
If we could somehow “remember” all the numbers we’ve seen before and quickly check if a
number has been seen already → we can immediately return true.​
This calls for fast membership checking, and that’s what a HashSet provides.

🧠 Approach
 1.​ Create an empty HashSet<Integer>.​

2.​ Traverse each number x in nums.​

3.​ For every number:​

○​ If x already exists in the set → duplicate found → return true.​

○​ Else, insert x into the set.​

4.​ If loop finishes without finding duplicates → return false.​

This works because:

●​ Insertion and lookup in a HashSet are O(1) average time.​

●​ We check each element once → O(n) total.​

💻 Java Code (with driver & comments)

import java.util.HashSet;

public class ContainsDuplicate {

// Function to check if array contains any duplicate

public static boolean containsDuplicate(int[] nums) {
// HashSet stores unique elements only
HashSet<Integer> seen = new HashSet<>();

for (int num : nums) {

// If element already seen, duplicate found
if (seen.contains(num)) {
return true;
}
// Otherwise, add element to set
seen.add(num);
}
// No duplicates found
return false;
}

// Driver code
public static void main(String[] args) {
 int[] nums1 = {1, 2, 3, 1};
int[] nums2 = {1, 2, 3, 4};
int[] nums3 = {1,1,1,3,3,4,3,2,4,2};

System.out.println(containsDuplicate(nums1)); // true
System.out.println(containsDuplicate(nums2)); // false
System.out.println(containsDuplicate(nums3)); // true
}
}

📊 Time Complexity Analysis

Operation Explanation Complexity

Iterating over n We visit each element once O(n)

elements

HashSet contains() Average O(1) lookup per O(1)

element

HashSet add() Average O(1) per insertion O(1)

Total O(n) * (O(1)+O(1)) ≈ O(n)** O(n)

⚠️ Worst case (all hash collisions): O(n²),​

but in Java 8+, long collision chains become balanced trees → O(n log n)
worst-case.​
Average remains O(n).

🧮 Space Complexity
●​ HashSet may store up to all elements (if no duplicates) → O(n) extra space.​

●​ Only a few variables otherwise → negligible overhead.​

✅ Space Complexity = O(n)

🔍 Dry Run Example

Let’s dry run with:​
nums = [1, 2, 3, 1]
 Ste num seen set Action seen set Output
p (before) (after)

1 1 {} not found → add 1 {1} —

2 2 {1} not found → add 2 {1,2} —

3 3 {1,2} not found → add 3 {1,2,3} —

4 1 {1,2,3} found → return true — ✅ true

Return true.

🧩 Key Takeaways
●​ Pattern used: “Seen-before” detection → HashSet.​

●​ Always think HashSet when you need quick duplicate detection or membership
test.​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

●​ Works for both sorted and unsorted arrays.​

Perfect 🚀
Let’s move on to:

🧩 2. Valid Anagram
📝 Problem Statement
Given two strings s and t, return true if t is an anagram of s, and false otherwise.

An anagram is a word or phrase formed by rearranging the letters of another

word or phrase, typically using all the original letters exactly once.
🔹 Examples
Example 1:
Input: s = "anagram", t = "nagaram"
Output: true
Explanation: Both strings contain the same letters with the same frequency.

Example 2:
Input: s = "rat", t = "car"
Output: false
Explanation: 'a' and 'r' are common, but 't' and 'c' differ.

💡 Intuition
Two strings are anagrams if:

●​ They have the same characters​

●​ Each character appears the same number of times in both​

So, we can:

1.​ Count how many times each character appears in s.​

2.​ Decrease the count for each character in t.​

3.​ If any count becomes negative or nonzero at the end → not an anagram.​

Since we’re only dealing with lowercase English letters (as per LeetCode constraints), we
can use a simple fixed-size array of length 26 instead of a HashMap for faster
performance.

🧠 Approach
Option 1 — Using Counting Array (Optimal)

1.​ If lengths differ → immediately return false.​

 2.​ Initialize an array count[26] to zero.​

3.​ For each character c in s: count[c - 'a']++​

4.​ For each character c in t: count[c - 'a']--​

5.​ Finally, if any count is nonzero → not an anagram.​

✅ O(n) time, O(1) space (constant 26 letters).

💻 Java Code (with driver & comments)

public class ValidAnagram {

public static boolean isAnagram(String s, String t) {

// If lengths differ, they can’t be anagrams
if (s.length() != t.length()) return false;

// Array of size 26 for 'a' to 'z'

int[] count = new int[26];

// Count frequencies for s and t

for (int i = 0; i < s.length(); i++) {
count[s.charAt(i) - 'a']++;
count[t.charAt(i) - 'a']--;
}

// If any character count != 0, not an anagram

for (int c : count) {
if (c != 0) return false;
}

return true; // All counts balanced → anagram

}

// Driver code
public static void main(String[] args) {
String s1 = "anagram", t1 = "nagaram";
String s2 = "rat", t2 = "car";

System.out.println(isAnagram(s1, t1)); // true

System.out.println(isAnagram(s2, t2)); // false
}
}

📊 Time Complexity Analysis

Step Operation Complexity

Count frequencies Iterate over both strings once O(n)

Final check of 26 Constant time (26 letters) O(1)

counts

Total Time O(n)

Space 26-length int array = O(1)

constant

🧮 Space Complexity
●​ Array of size 26 → constant → O(1).​

●​ No extra data structures used.​

🔍 Dry Run Example

Let’s dry-run with s = "anagram", t = "nagaram":

Ste Char from s Char from t Change in

p count[]

1 a (+1) n (-1) a:1, n:-1

2 n (+1) a (-1) a:0, n:0

3 a (+1) g (-1) a:1, g:-1

4 g (+1) a (-1) g:0, a:0

5 r (+1) r (-1) r:0

6 a (+1) a (-1) a:0

7 m (+1) m (-1) m:0

All counts are 0 → ✅ Anagram → return true.

🧩 Alternate Approach — Sorting
You can also sort both strings and compare.

import java.util.Arrays;

public static boolean isAnagram(String s, String t) {

if (s.length() != t.length()) return false;

char[] sArr = s.toCharArray();

char[] tArr = t.toCharArray();

Arrays.sort(sArr);

Arrays.sort(tArr);

return Arrays.equals(sArr, tArr);

●​ Time: O(n log n) due to sorting.​

●​ Space: O(1) or O(n) depending on sorting algorithm.​

●​ ✅ Simpler to write, but slower than counting approach.​

⚙️ Key Takeaways
●​ Pattern: Frequency counting → array or HashMap.​

●​ Optimal Solution: Counting array (O(n) time, O(1) space).​

●​ Sorting method: Simpler, but O(n log n).​

●​ Common Mistake: Forget to check string lengths first.​

✅ Final Answer Summary

 ●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

●​ Approach: Character frequency counting​

●​ Pattern used: Hashing / Counting

Excellent 🔥​
Let’s move on to the next one in Arrays & Hashing.

🧩 3. Two Sum
📝 Problem Statement
Given an array of integers nums and an integer target, return indices of the two numbers
such that they add up to the target.​
You may assume that each input would have exactly one solution, and you may not use
the same element twice.​
You can return the answer in any order.

🔹 Examples
Example 1:
Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: nums[0] + nums[1] = 2 + 7 = 9

Example 2:
Input: nums = [3,2,4], target = 6
Output: [1,2]
Explanation: nums[1] + nums[2] = 2 + 4 = 6

Example 3:
Input: nums = [3,3], target = 6
Output: [0,1]
💡 Intuition
We need two numbers whose sum equals a given target.​
If we iterate through the array, for each element x, the number we need to pair with it is
target - x.​
So, if we could quickly check whether target - x has already appeared, we can
immediately find the solution.

This screams HashMap! — it allows constant-time lookups of previously seen elements.

🧠 Approach
1.​ Create an empty HashMap<Integer, Integer> to store:​
(number → its index).​

2.​ Traverse through nums using index i.​

3.​ For each number nums[i]:​

○​ Compute complement = target - nums[i].​

○​ If complement exists in the map → we found the answer.​

○​ Else, add (nums[i], i) to the map.​

4.​ Return indices [map.get(complement), i].​

This works because:

●​ Every time we see a number, we record where it occurred.​

●​ Lookup in HashMap is O(1) on average.​

💻 Java Code (with driver & comments)

import java.util.HashMap;
import java.util.Arrays;

public class TwoSum {

public static int[] twoSum(int[] nums, int target) {

 // Map to store number -> its index
HashMap<Integer, Integer> map = new HashMap<>();

for (int i = 0; i < nums.length; i++) {

int complement = target - nums[i];

// If complement exists in map, we found the pair

if (map.containsKey(complement)) {
return new int[]{map.get(complement), i};
}

// Store current number with its index

map.put(nums[i], i);
}

// If no pair found (shouldn’t happen as per problem constraints)

return new int[]{-1, -1};
}

// Driver code
public static void main(String[] args) {
int[] nums1 = {2, 7, 11, 15};
int target1 = 9;

int[] result1 = twoSum(nums1, target1);

System.out.println(Arrays.toString(result1)); // [0, 1]

int[] nums2 = {3, 2, 4};

int target2 = 6;
System.out.println(Arrays.toString(twoSum(nums2, target2))); // [1,
2]

int[] nums3 = {3, 3};

int target3 = 6;
System.out.println(Arrays.toString(twoSum(nums3, target3))); // [0,
1]
}
}

📊 Time Complexity Analysis

Step Operation Complexity

Traverse all n elements One pass O(n)

Each lookup in HashMap Average O(1) O(1)

Each insertion O(1) O(1)

Total O(n) * (O(1)+O(1)) O(n)

🧮 Space Complexity
●​ HashMap may store up to n entries in worst case → O(n) space.​

●​ A few integer variables → negligible.​

✅ Space = O(n)

🔍 Dry Run Example

Let’s dry-run with:​
nums = [2,7,11,15], target = 9

Ste i nums[ complement = 9 - HashMap Action Output

p i] nums[i] (value→index)

1 0 2 7 {} 7 not found → —
add 2:0

2 1 7 2 {2=0} 2 found! → ✅
return [0,1] [0,1]

Output → [0, 1].

⚙️ Alternate Approaches
Approach 1 — Brute Force

Check all pairs (i, j) → return if nums[i] + nums[j] == target.

●​ Time: O(n²)​

❌
●​ Space: O(1)​
Not efficient for large inputs.​
Approach 2 — Sorting + Two Pointers

●​ Sort the array (but we lose original indices unless stored separately).​

●​ Use two pointers from both ends to find sum = target.​

✅
●​ Time: O(n log n), Space: O(n) for index tracking.​
Works for “Two Sum II” problem where array is sorted.​

🧩 Key Takeaways
●​ Pattern: HashMap lookup for complement.​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

●​ Common Interview Trick: Compute complement = target - current.​

●​ Edge cases: Same number twice → handled by storing index after checking.​

✅ Final Answer Summary

●​ Approach: HashMap (number → index)​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

●​ Pattern used: Hashing / Complement Map​

Awesome ⚡ ​
Let’s dive into the next one from Arrays & Hashing — one of the most classic and
important problems.

🧩 4. Group Anagrams
📝 Problem Statement
Given an array of strings strs, group the anagrams together.​
You can return the answer in any order.

Two strings are anagrams if they contain the same characters in the same
frequencies, regardless of order.

🔹 Examples
Example 1:
Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

Example 2:
Input: strs = [""]
Output: [[""]]

Example 3:
Input: strs = ["a"]
Output: [["a"]]

💡 Intuition
We need to group words that are anagrams of each other.

Observation:

●​ Two words are anagrams if their sorted characters are the same.​

○​ Example: "eat" → "aet", "tea" → "aet" → same key.​

●​ Alternatively, we can use a frequency count of letters (a–z) as a signature key:​

○​ Example: "eat" → {a:1, e:1, t:1}​

→ key "1a1e1t" or "1,0,0,..." (for all 26 letters).​

Both methods can uniquely represent an anagram group.

🧠 Approach 1 — Using Sorted String as Key (Simpler)
1.​ Create a HashMap<String, List<String>>.​

○​ Key = sorted string​

○​ Value = list of words that match this sorted key​

2.​ For each string s in strs:​

○​ Convert to char array, sort it, convert back to string.​

○​ Add s to the list in the map for this key.​

3.​ Return all lists from the map.​

✅ Time-efficient and very clean.

💻 Java Code (with driver & comments)

import java.util.*;

public class GroupAnagrams {

public static List<List<String>> groupAnagrams(String[] strs) {

// Map: sorted word -> list of anagrams
HashMap<String, List<String>> map = new HashMap<>();

for (String s : strs) {

// Sort the characters in the string
char[] chars = s.toCharArray();
Arrays.sort(chars);
String key = new String(chars);

// Add original string to the corresponding list

map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
}

// Return all grouped lists

return new ArrayList<>(map.values());
}

// Driver code
public static void main(String[] args) {
 String[] strs = {"eat", "tea", "tan", "ate", "nat", "bat"};
List<List<String>> result = groupAnagrams(strs);
System.out.println(result);
}
}

🔍 Dry Run Example

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

Word Sorted Key HashMap after insertion

eat aet { "aet" → ["eat"] }

tea aet { "aet" → ["eat","tea"] }

tan ant { "aet"→["eat","tea"], "ant"→["tan"] }

ate aet { "aet"→["eat","tea","ate"], "ant"→["tan"] }

nat ant { "aet"→["eat","tea","ate"], "ant"→["tan","nat"] }

bat abt { "aet"→["eat","tea","ate"], "ant"→["tan","nat"], "abt"→["bat"] }

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

📊 Time Complexity Analysis

Operation Explanation Complexity

Sorting each string Each string of length k O(k log k)

Loop over all strings (n total) Repeat above for each O(n × k log k)

HashMap operations Insert/get average —

O(1)

Total O(n × k log k)

Space Store all strings in O(n × k)

map

🧠 Approach 2 — Using Character Count as Key (Optimized)

Instead of sorting (O(k log k)), we can build a 26-length frequency array for each word and
use that as the key.

1.​ For each string:​

○​ Initialize an int[26] count array.​

○​ Count frequency of each letter.​

○​ Convert count array into a unique string key like "1#0#2#0#...".​

2.​ Store in HashMap<key, list>.​

This avoids sorting and runs in O(n × k) time.

💻 Java Code (Optimized)

import java.util.*;

public class GroupAnagramsOptimized {

public static List<List<String>> groupAnagrams(String[] strs) {

HashMap<String, List<String>> map = new HashMap<>();

for (String s : strs) {

int[] count = new int[26];
for (char c : s.toCharArray()) {
count[c - 'a']++;
}

// Convert count array to string key

StringBuilder keyBuilder = new StringBuilder();
for (int i = 0; i < 26; i++) {
keyBuilder.append(count[i]).append('#');
}
String key = keyBuilder.toString();

map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);

}

return new ArrayList<>(map.values());

}

public static void main(String[] args) {

 String[] strs = {"eat", "tea", "tan", "ate", "nat", "bat"};
System.out.println(groupAnagrams(strs));
}
}

✅ Time: O(n × k)​

✅ Space: O(n × k)

⚙️ Comparison
Approach Key Time Space Notes

Sorting Sorted string O(n × k log k) O(n × k) Simpler, easier to

remember

Counting Frequency O(n × k) O(n × k) Faster for large input

vector

🧩 Key Takeaways
●​ Pattern: HashMap grouping by signature (sorted or frequency key).​

●​ Real-world concept: Hash-based grouping / hashing equivalence classes.​

●​ Time Complexity:​

○​ Sorting: O(n × k log k)​

○​ Counting: O(n × k)​

●​ Space Complexity: O(n × k)​

●​ Interview tip: Mention both approaches and trade-offs.​

✅ Final Answer Summary

●​ Approach: Group by HashMap key (sorted or frequency array).​

●​ Time: O(n × k log k) or O(n × k)​

●​ Space: O(n × k)​

 ●​ Pattern: Hashing / Grouping

Perfect 💪​
Let’s move on to Problem 5 in the Arrays & Hashing section — one of the most
must-know problems for both interviews and competitive programming.

🧩 5. Top K Frequent Elements

📝 Problem Statement
Given an integer array nums and an integer k, return the k most frequent elements.​
You may return the answer in any order.

🔹 Examples
Example 1:
Input: nums = [1,1,1,2,2,3], k = 2
Output: [1,2]
Explanation: 1 appears 3 times, 2 appears 2 times → top 2 frequent elements are 1 and 2.

Example 2:
Input: nums = [1], k = 1
Output: [1]

💡 Intuition
We need the elements that appear most frequently.​
This naturally suggests:

1.​ First count the frequency of each number (→ HashMap).​

2.​ Then pick the top k based on frequency.​

But how do we efficiently find the top k elements?

We can use:
 ●​ A Heap/PriorityQueue (min-heap to keep top k).​

●​ Or a Bucket Sort method (linear time).​

🧠 Approach 1 — HashMap + Min Heap (Priority Queue)

1.​ Traverse the array, build a frequency map:​
Map<Integer, Integer> freq = new HashMap<>();​

2.​ Create a Min Heap (PriorityQueue) that orders elements by frequency.​

3.​ For each (num, freq):​

○​ Push into heap.​

○​ If heap size exceeds k, remove the least frequent element.​

4.​ The heap now contains the top k frequent elements.​

5.​ Extract and return the results.​

💻 Java Code (Heap-based)

import java.util.*;

public class TopKFrequentElements {

public static int[] topKFrequent(int[] nums, int k) {

// Step 1: Count frequency
Map<Integer, Integer> freqMap = new HashMap<>();
for (int num : nums) {
freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
}

// Step 2: Create a Min Heap based on frequency

PriorityQueue<Map.Entry<Integer, Integer>> heap =
new PriorityQueue<>((a, b) -> a.getValue() - b.getValue());

// Step 3: Keep only top k frequent elements in heap

for (Map.Entry<Integer, Integer> entry : freqMap.entrySet()) {
heap.add(entry);
 if (heap.size() > k) {
heap.poll(); // remove least frequent
}
}

// Step 4: Extract elements from heap into result array

int[] res = new int[k];
for (int i = k - 1; i >= 0; i--) {
res[i] = heap.poll().getKey();
}

return res;
}

// Driver code
public static void main(String[] args) {
int[] nums1 = {1,1,1,2,2,3};
int k1 = 2;
System.out.println(Arrays.toString(topKFrequent(nums1, k1))); // [1,
2]

int[] nums2 = {1};

int k2 = 1;
System.out.println(Arrays.toString(topKFrequent(nums2, k2))); // [1]
}
}

🔍 Dry Run Example

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

Step Operation Data Structure

Build freqMap {1=3, 2=2, 3=1}

Add (1,3) to heap heap=[(1,3)] size=1

Add (2,2) to heap heap=[(2,2),(1,3)] size=2

Add (3,1) to heap size>2 → poll (least freq=3,1) heap=[(2,2),(1,3)]

Extract top 2 → [1,2] ✅

Output → [1, 2].
📊 Time Complexity Analysis
Step Operation Complexity

Build frequency map Iterate through n elements O(n)

Heap operations Insert each unique number once (m = unique O(m log k)
count)

Extract k elements O(k log k)

Total O(n log k) (since m ≤ n)

Space HashMap + heap O(n)

✅ Efficient when n is large and k is small.

🧠 Approach 2 — Bucket Sort (Optimal Linear Solution)

Idea:

●​ Frequency can range from 1 to n.​

●​ We can create “buckets” where bucket[i] = list of numbers with frequency i.​

●​ Then, iterate buckets from high to low to collect top k elements.​

💻 Java Code (Bucket Sort Approach)

import java.util.*;

public class TopKFrequentBucket {

public static int[] topKFrequent(int[] nums, int k) {

Map<Integer, Integer> freqMap = new HashMap<>();
for (int num : nums) {
freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
}

// Create buckets where index = frequency

List<Integer>[] buckets = new List[nums.length + 1];
for (int key : freqMap.keySet()) {
int freq = freqMap.get(key);
if (buckets[freq] == null) {
 buckets[freq] = new ArrayList<>();
}
buckets[freq].add(key);
}

// Collect top k frequent elements from buckets

List<Integer> result = new ArrayList<>();
for (int i = buckets.length - 1; i >= 0 && result.size() < k; i--) {
if (buckets[i] != null) {
result.addAll(buckets[i]);
}
}

// Convert list to array

return result.stream().mapToInt(i -> i).limit(k).toArray();
}

public static void main(String[] args) {

int[] nums = {1,1,1,2,2,3};
int k = 2;
System.out.println(Arrays.toString(topKFrequent(nums, k))); // [1, 2]
}
}

🔍 Dry Run (Bucket Approach)

Input: [1,1,1,2,2,3], k = 2

1.​ Frequency map → {1=3, 2=2, 3=1}​

Create buckets (indices = freq):​

​
0: []
1: [3]
2: [2]
3: [1]

2.​
3.​ Iterate from high freq → low:​

○​ i = 3 → add [1]​

○​ i = 2 → add [2]​
 ○​ Collected k = 2 elements → ✅ [1,2]​

📊 Complexity (Bucket Sort)

Step Operation Complexity

Build freqMap O(n)

Fill buckets O(n)

Traverse O(n + k)
buckets

Total Time O(n)

Space O(n)

✅ Truly linear time solution.

⚙️ Comparison
Approach Time Spac Notes
e

Heap O(n log k) O(n) Better when k ≪ n

Bucket Sort O(n) O(n) Best overall; linear time

🧩 Key Takeaways
●​ Pattern: Frequency counting + top-k extraction.​

●​ HashMap → to count.​

●​ Heap or Bucket Sort → to get most frequent elements.​

●​ Interview Tip:​
Mention both approaches — heap is flexible, bucket sort is optimal for this specific
problem.​

●​ Edge Cases:​

○​ All numbers same → just return that number.​

 ○​ k = 1 → single most frequent.​

○​ Negative numbers → handled naturally by HashMap.​

✅ Final Answer Summary

●​ Approach 1 (Heap): O(n log k), O(n)​

●​ Approach 2 (Bucket Sort): O(n), O(n)​

●​ Pattern used: Frequency Map + Selection via Heap/Bucket​

●​ Best Solution: Bucket Sort (for linear performance)​

Excellent ⚡ ​
Let’s continue with Problem 6 in the Arrays & Hashing section — a conceptual and
implementation-heavy question that tests string serialization and parsing logic.

🧩 6. Encode and Decode Strings

📝 Problem Statement
Design an algorithm to encode a list of strings into a single string,​
and decode that single string back into the original list of strings.

You must ensure that the encoded string can be decoded correctly, even if it contains
special characters like spaces or #.

🔹 Examples
Example 1:
Input: ["lint","code","love","you"]
Output: ["lint","code","love","you"]
Explanation:
Encoded string could be "4#lint4#code4#love3#you"
Example 2:
Input: ["hello","world"]
Output: ["hello","world"]
Encoded form: "5#hello5#world"

💡 Intuition
We need a reversible transformation between:

List<String> ↔ Single Encoded String

Challenges:

●​ Words can contain spaces or special characters.​

●​ We can’t just join by a delimiter (like commas), because strings might include that
character.​

Hence, we must store both the length and the string in a predictable pattern.

🧠 Core Idea
Use Length Prefixing

For every string:

●​ Prefix it with its length and a special separator (e.g., #).​

●​ Example: "lint" → "4#lint"​

When decoding:

●​ Read characters until # to get the length.​

●​ Then read exactly length characters to reconstruct the string.​

This ensures no ambiguity even if strings contain # or spaces.

💻 Java Code (Encode and Decode Strings)
import java.util.*;

public class EncodeDecodeStrings {

// Encode a list of strings to a single string

public static String encode(List<String> strs) {
StringBuilder encoded = new StringBuilder();
for (String s : strs) {
// Store length of string + '#' + string itself
encoded.append(s.length()).append('#').append(s);
}
return encoded.toString();
}

// Decode a single string back to list of strings

public static List<String> decode(String s) {
List<String> result = new ArrayList<>();
int i = 0;

while (i < s.length()) {

// Step 1: Read length
int j = i;
while (s.charAt(j) != '#') {
j++;
}
int length = Integer.parseInt(s.substring(i, j));

// Step 2: Move after '#' and read `length` characters

i = j + 1;
String word = s.substring(i, i + length);
result.add(word);

// Step 3: Move pointer to next string start

i = i + length;
}

return result;
}

// Driver Code
public static void main(String[] args) {
List<String> strs = Arrays.asList("lint", "code", "love", "you");

String encoded = encode(strs);

 System.out.println("Encoded: " + encoded);

List<String> decoded = decode(encoded);

System.out.println("Decoded: " + decoded);
}
}

🔍 Dry Run Example

Input:

["lint","code","love","you"]

Encoding:

String Encoded Part Final Encoded

lint 4#lint 4#lint

code 4#code 4#lint4#code

love 4#love 4#lint4#code4#love

you 3#you 4#lint4#code4#love3#you

Encoded String →​
"4#lint4#code4#love3#you"

Decoding:

1.​ Start at i=0​

Read length = 4​
Read next 4 chars → "lint"​
Add → ["lint"]​

2.​ Next start at i=6​

Read length = 4​
Read "code" → ["lint","code"]​

3.​ Next start at i=12​

Read length = 4​
Read "love" → ["lint","code","love"]​
 4.​ Next start at i=18​
Read length = 3​
Read "you" → ["lint","code","love","you"]​

✅ Output = ["lint","code","love","you"]

📊 Complexity Analysis
Operation Explanation Complexity

Encoding Iterate each string once O(N) total length of strings

Decoding Parse each encoded part O(N) total length of strings

Total Time O(N)

Space StringBuilder + output list O(N)

(N = total number of characters in all strings combined)

⚙️ Edge Cases
Case Example Handling

Empty list [] Encodes to ""

Empty strings ["", "abc"] → Works perfectly

0#3#abc

Special chars (#, ["ab#cd","xy"] Safe — length prefix isolates it

spaces)

🧠 Alternative Approaches
Approach Description Issue

Join with delimiter "lint,code,lo Fails if strings contain commas

ve"

JSON encoding Use libraries Not allowed in interviews

Length prefix len#string ✅ Most robust, optimal for interviews

🧩 Key Takeaways
●​ Pattern: String serialization & deserialization​

●​ Concept: Length prefix encoding​

●​ Time: O(N)​

●​ Space: O(N)​

●​ Why this works: No ambiguity due to explicit length parsing.​

✅ Final Answer Summary

●​ Encode: Append length#string​

●​ Decode: Parse length, extract substring​

●​ Time: O(N)​

●​ Space: O(N)​

●​ Pattern: String encoding/decoding (serialization)​

Perfect🚀 ​
Let’s move on to Problem 7 in the Arrays & Hashing section — one of the most
fundamental array manipulation problems that tests your understanding of prefix/suffix
computation and space optimization.

🧩 7. Product of Array Except Self

📝 Problem Statement
Given an integer array nums, return an array answer such that:

answer[i] = product of all elements in nums except nums[i].

You must solve it without using division, and in O(n) time.

🔹 Examples
Example 1:
Input: nums = [1,2,3,4]
Output: [24,12,8,6]
Explanation:
- answer[0] = 2×3×4 = 24
- answer[1] = 1×3×4 = 12
- answer[2] = 1×2×4 = 8
- answer[3] = 1×2×3 = 6

Example 2:
Input: nums = [-1,1,0,-3,3]
Output: [0,0,9,0,0]

💡 Intuition
We need the product of all elements except self, but without division.

If we were allowed to divide:

totalProduct = product of all numbers

answer[i] = totalProduct / nums[i]

However, division fails for zero elements and isn’t allowed.

So we simulate the effect using prefix and suffix products.

🧠 Key Idea
Let’s define:

●​ prefix[i] = product of all elements to the left of i.​

●​ suffix[i] = product of all elements to the right of i.​

Then:

answer[i] = prefix[i] * suffix[i]

We can compute both arrays in two passes.

💻 Approach 1 — Using Prefix & Suffix Arrays

import java.util.*;

public class ProductOfArrayExceptSelf {

public static int[] productExceptSelf(int[] nums) {

int n = nums.length;

int[] prefix = new int[n];

int[] suffix = new int[n];
int[] result = new int[n];

// Step 1: Compute prefix products

prefix[0] = 1; // no element to left
for (int i = 1; i < n; i++) {
prefix[i] = prefix[i - 1] * nums[i - 1];
}

// Step 2: Compute suffix products

suffix[n - 1] = 1; // no element to right
for (int i = n - 2; i >= 0; i--) {
suffix[i] = suffix[i + 1] * nums[i + 1];
}

// Step 3: Multiply prefix and suffix

for (int i = 0; i < n; i++) {
result[i] = prefix[i] * suffix[i];
}

return result;
}

// Driver Code
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4};
System.out.println(Arrays.toString(productExceptSelf(nums)));
}
}

🔍 Dry Run Example

Input: [1, 2, 3, 4]

Index nums[i] prefix[i] suffix[i] result[i] = prefix × suffix

0 1 1 24 24

1 2 1 12 12

2 3 2 4 8

3 4 6 1 6

✅ Output → [24, 12, 8, 6]

🧠 Approach 2 — Space Optimized (In-Place)

We can avoid using separate prefix/suffix arrays.​
Compute prefix product directly in the result array, then multiply by running suffix
product in reverse.

💻 Optimized Java Code

import java.util.*;

public class ProductOfArrayExceptSelfOptimized {

public static int[] productExceptSelf(int[] nums) {

int n = nums.length;
int[] result = new int[n];

// Step 1: Build prefix product directly into result

result[0] = 1;
for (int i = 1; i < n; i++) {
result[i] = result[i - 1] * nums[i - 1];
}

// Step 2: Multiply with suffix products (right to left)

int suffix = 1;
for (int i = n - 1; i >= 0; i--) {
result[i] *= suffix;
suffix *= nums[i];
}

return result;
 }

// Driver code
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4};
System.out.println(Arrays.toString(productExceptSelf(nums))); //
[24,12,8,6]
}
}

🔍 Dry Run (Optimized Approach)

Input: [1, 2, 3, 4]

Step 1 — Prefix pass

i nums[i] result[i] (prefix)

0 1 1

1 2 1×1 = 1

2 3 1×2 = 2

3 4 2×3 = 6

result = [1, 1, 2, 6]

Step 2 — Suffix pass

i suffi result[i] × suffix new
x suffix

3 1 6×1 = 6 4

2 4 2×4 = 8 12

1 12 1×12 = 12 24

0 24 1×24 = 24 —

✅ Final Output: [24, 12, 8, 6]

📊 Complexity Analysis
Step Operation Time Spac
e
 Prefix computation Single pass O(n) O(1)*

Suffix computation Single reverse O(n) O(1)*

pass

Total O(n) O(1) (output excluded)

✅ We don’t count the output array in space complexity.

⚙️ Edge Cases
Case Example Explanation

Zeros present [1,2,0,4] Any zero makes all products zero except one
index

Multiple zeros [0,0,3] All results = 0

Negative [-1,2,-3, Works fine

numbers 4]

Single element [5] [1] (no other elements)

🧩 Key Takeaways
●​ Pattern: Prefix & Suffix computation.​

●​ Concepts: Cumulative product, space optimization.​

●​ Time: O(n)​

●​ Space: O(1)​

●​ No Division Used ✅​
●​ Common Pitfall: Don’t multiply the current number when computing prefix/suffix —
use prior values only.​

✅ Final Answer Summary

●​ Approach 1: Prefix + Suffix arrays → O(n) time, O(n) space​
 ●​ Approach 2: Optimized single array → O(n) time, O(1) space​

●​ Pattern: Prefix/Suffix Product​

●​ Edge Cases handled: Zeros and negatives​

Perfect 🎯​
We’re now at Problem 8 of the Arrays & Hashing section — one of the most logic-based
grid validation problems.​
This problem tests hashing, 2D traversal, and data validation skills — very common in
interviews.

🧩 8. Valid Sudoku
📝 Problem Statement
Determine if a 9 × 9 Sudoku board is valid.​
Only the filled cells need to be validated according to the following rules:

1.​ Each row must contain the digits 1–9 without repetition.​

2.​ Each column must contain the digits 1–9 without repetition.​

3.​ Each of the nine 3 × 3 sub-boxes** must contain the digits 1–9 without repetition.​

The board can be partially filled — empty cells are denoted by '.'.

🔹 Example
Example 1:
Input:
[
["5","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".",".","6",".",".",".","3"],
["4",".",".","8",".","3",".",".","1"],
["7",".",".",".","2",".",".",".","6"],
 [".","6",".",".",".",".","2","8","."],
[".",".",".","4","1","9",".",".","5"],
[".",".",".",".","8",".",".","7","9"]
]

Output: true

💡 Intuition
We only need to check if any rule is violated:

●​ Duplicate in the same row → invalid​

●​ Duplicate in the same column → invalid​

●​ Duplicate in the same 3×3 box → invalid​

We can maintain three sets for tracking seen numbers:

●​ rows[i] → digits in row i​

●​ cols[j] → digits in column j​

●​ boxes[b] → digits in box b, where b = (i / 3) * 3 + (j / 3)​

🧠 Approach
1.​ Loop through every cell (i, j) in the board.​

2.​ Skip if the cell is '.'.​

3.​ Compute:​

○​ row = i​

○​ col = j​

○​ box = (i / 3) * 3 + (j / 3)​

4.​ Check if this digit already exists in any of the three sets.​
 ○​ If yes → invalid Sudoku (return false).​

○​ Otherwise, add the digit to the sets.​

5.​ If entire traversal completes → valid Sudoku (return true).​

💻 Java Code
import java.util.*;

public class ValidSudoku {

public static boolean isValidSudoku(char[][] board) {

// Step 1: Create hash sets for rows, columns, and boxes
HashSet<Character>[] rows = new HashSet[9];
HashSet<Character>[] cols = new HashSet[9];
HashSet<Character>[] boxes = new HashSet[9];

for (int i = 0; i < 9; i++) {

rows[i] = new HashSet<>();
cols[i] = new HashSet<>();
boxes[i] = new HashSet<>();
}

// Step 2: Traverse every cell

for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];

if (c == '.') continue; // skip empty cells

int boxIndex = (i / 3) * 3 + (j / 3);

// Step 3: Check if duplicate found

if (rows[i].contains(c) || cols[j].contains(c) ||
boxes[boxIndex].contains(c)) {
return false;
}

// Step 4: Add number to respective sets

rows[i].add(c);
cols[j].add(c);
boxes[boxIndex].add(c);
 }
}

return true;
}

// Driver code
public static void main(String[] args) {
char[][] board = {
{'5','3','.','.','7','.','.','.','.'},
{'6','.','.','1','9','5','.','.','.'},
{'.','9','8','.','.','.','.','6','.'},
{'8','.','.','.','6','.','.','.','3'},
{'4','.','.','8','.','3','.','.','1'},
{'7','.','.','.','2','.','.','.','6'},
{'.','6','.','.','.','.','2','8','.'},
{'.','.','.','4','1','9','.','.','5'},
{'.','.','.','.','8','.','.','7','9'}
};

System.out.println(isValidSudoku(board)); // true
}
}

🔍 Dry Run Example

Let's dry-run a small portion:

Cell (0,0) → '5'

●​ Row 0: {} → add '5'​

●​ Col 0: {} → add '5'​

●​ Box 0: {} → add '5'​

Next (0,1) → '3'

●​ Row 0: {'5'} → add '3'​

 ●​ Col 1: {} → add '3'​

●​ Box 0: {'5'} → add '3'​

Continue until end.

If a number appears again in the same row, col, or box → immediately invalid.

✅ Final Result: true (since no duplicates found).

📊 Complexity Analysis
Step Operation Time Spac
e

Traversing 9×9 grid 81 cells O(1) (constant

size)

HashSet operations Add/check → O(1) average O(1) per operation

Total Time O(1) (fixed grid)

Space 27 sets (9 rows + 9 cols + 9 O(1)

boxes)

Even though we use sets, the size of the grid is fixed (9×9), so it’s constant time
and space.

⚙️ Edge Cases
Case Example Result

Empty Sudoku all '.' ✅ true

Repeated number in duplicate in same row ❌ false
row

Repeated number in col duplicate in same column ❌ false

Repeated number in duplicate in same 3×3 ❌ false
box box

🧠 Alternate Approach (Bitmask Optimization)

Instead of sets, use bit manipulation for constant-time checks:

●​ Maintain 3 integer arrays rows[9], cols[9], boxes[9].​

●​ Each integer uses 9 bits to track numbers 1–9.​

●​ Fast and memory-efficient.​

✅ But in interviews, Set-based approach is preferred for clarity.

🧩 Key Takeaways
●​ Pattern: Hash-based validation​

●​ Concept: 2D traversal + unique constraints check​

●​ Time Complexity: O(1) (constant 9×9 grid)​

●​ Space Complexity: O(1) (27 sets max)​

●​ Key formula: boxIndex = (row / 3) * 3 + (col / 3)​

✅ Final Answer Summary

●​ Approach: Use 3 HashSets for row, col, box validation​

●​ Time: O(1) (81 cells)​

●​ Space: O(1)​

●​ Pattern: Hash-based validation on 2D grid​

Awesome 🔥 ​
Let’s move to Problem 9 — Longest Consecutive Sequence, one of the most popular
and important hashing problems in coding interviews.​
This question tests your understanding of sets, sequence continuity, and O(n)
optimization.
🧩 9. Longest Consecutive Sequence
📝 Problem Statement
Given an unsorted array of integers, return the length of the longest consecutive
elements sequence.

You must write an algorithm that runs in O(n) time.

🔹 Examples
Example 1:
Input: [100, 4, 200, 1, 3, 2]
Output: 4
Explanation: The longest consecutive sequence is [1, 2, 3, 4].

Example 2:
Input: [0,3,7,2,5,8,4,6,0,1]
Output: 9
Explanation: The sequence [0,1,2,3,4,5,6,7,8] is length 9.

Example 3:
Input: []
Output: 0

💡 Intuition
We are asked for longest consecutive sequence — numbers that appear consecutively (in
any order).​
Naively, we could:

●​ Sort the array (O(n log n))​

●​ Then count consecutive streaks.​

But we are required to do it in O(n) time.​

This means no sorting — we must use a HashSet for O(1) lookups.
🧠 Approach
1.​ Store all numbers in a HashSet for fast lookup.​

2.​ For each number num, check if it’s the start of a sequence:​

○​ i.e., if (num - 1) is not in the set.​

3.​ If yes:​

○​ Start counting upward: (num + 1), (num + 2)... until number not
found.​

○​ Track length of this sequence.​

4.​ Keep updating the maximum sequence length.​

5.​ Return the maximum length found.​

This ensures each number starts a sequence only once, making the algorithm O(n).

💻 Java Code
import java.util.*;

public class LongestConsecutiveSequence {

public static int longestConsecutive(int[] nums) {

if (nums.length == 0) return 0;

HashSet<Integer> set = new HashSet<>();

for (int num : nums) {
set.add(num);
}

int longestStreak = 0;

for (int num : set) {

// Only start counting if 'num' is the start of a sequence
if (!set.contains(num - 1)) {
int currentNum = num;
int currentStreak = 1;

// Count consecutive numbers

 while (set.contains(currentNum + 1)) {
currentNum++;
currentStreak++;
}

longestStreak = Math.max(longestStreak, currentStreak);

}
}

return longestStreak;
}

// Driver Code
public static void main(String[] args) {
int[] nums = {100, 4, 200, 1, 3, 2};
System.out.println("Longest Consecutive Sequence Length: " +
longestConsecutive(nums));
}
}

🔍 Dry Run Example

Input: [100, 4, 200, 1, 3, 2]

Step 1: Convert to set → {100, 4, 200, 1, 3, 2}​

Step 2: Iterate through set

num num-1 in Action Sequenc Length Max

set? e

100 ❌ start [100] 1 1

4 ✅ (3 exists) skip - - 1

200 ❌ start [200] 1 1

1 ❌ start [1,2,3,4] 4 4

3 ✅ (2 exists) skip - - 4

2 ✅ (1 exists) skip - - 4

✅ Output = 4
📊 Complexity Analysis
Step Operation Complexity

Build HashSet O(n) Inserting each element

Iterate + check O(n) Each element checked once

sequence

Inner loop O(n) total Each number processed once

overall

Total Time O(n)

Space O(n) (for the set)

⚙️ Edge Cases
Case Input Output Explanation

Empty array [] 0 No numbers

All same numbers [2,2,2] 1 Only one unique number

Already sorted [1,2,3,4,5] 5 One full sequence

consecutive

Negative numbers [-2,-1,0,1] 4 Works fine

Unordered [10,5,7,6,8, 4 [5,6,7,8]

11]

🧠 Why This Works

We avoid redundant counting:

●​ Each sequence is started only from its smallest element (num-1 not in set).​

●​ So we only traverse each consecutive streak once.​

🔩 Alternative Approaches
Approach Description Complexity Notes
Sorting + iteration Sort then count O(n log n) Simpler but slower
consecutive

Union-Find Group connected numbers O(n α(n)) Overkill

HashSet (ours) Track only starts ✅ O(n) Optimal

🧩 Key Takeaways
●​ Pattern: HashSet lookup for sequence detection​

●​ Core Idea: Only start counting from sequence heads​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

●​ Most common asked variant: Longest streak of consecutive integers​

✅ Final Summary
●​ Approach: Use HashSet to detect consecutive streaks​

●​ Time: O(n)​

●​ Space: O(n)​

●​ Logic: Start counting only from smallest element of each sequence​

TWO POINTERS

🧩 Two Pointers – Problem 1: Valid Palindrome

📝 Problem Statement
Given a string s, determine if it is a palindrome, considering only alphanumeric
characters and ignoring cases.

A palindrome reads the same forward and backward.

🔹 Examples
Example 1:
Input: "A man, a plan, a canal: Panama"
Output: true
Explanation: Ignoring non-alphanumeric characters and case → "amanaplanacanalpanama"

Example 2:
Input: "race a car"
Output: false

Example 3:
Input: ""
Output: true

💡 Intuition
We need to check if a string reads the same from both ends, while ignoring:

●​ Spaces​

●​ Punctuation​

●​ Case differences​

A two-pointer approach is ideal:

●​ One pointer left at start​

●​ One pointer right at end​

●​ Move towards the center while comparing valid alphanumeric characters​

🧠 Approach
1.​ Initialize left = 0, right = s.length() - 1.​

2.​ While left < right:​

○​ Skip characters that are not alphanumeric.​

○​ Convert both characters to lowercase.​

○​ Compare characters:​

■​ If unequal → return false​

■​ Else → move both pointers inward​

3.​ If traversal completes → return true​

💻 Java Code
public class ValidPalindrome {

public static boolean isPalindrome(String s) {

int left = 0, right = s.length() - 1;

while (left < right) {

// Skip non-alphanumeric characters from left
while (left < right &&
!Character.isLetterOrDigit(s.charAt(left))) {
left++;
}

// Skip non-alphanumeric characters from right

while (left < right &&
!Character.isLetterOrDigit(s.charAt(right))) {
right--;
}

// Compare characters ignoring case

if (Character.toLowerCase(s.charAt(left)) !=
Character.toLowerCase(s.charAt(right))) {
return false;
}
 left++;
right--;
}

return true;
}

// Driver Code
public static void main(String[] args) {
String s1 = "A man, a plan, a canal: Panama";
String s2 = "race a car";
System.out.println(isPalindrome(s1)); // true
System.out.println(isPalindrome(s2)); // false
}
}

🔍 Dry Run Example

Input: "A man, a plan, a canal: Panama"

1.​ Initialize left = 0, right = 29​

2.​ Compare 'A' and 'a' → equal → move pointers​

3.​ Skip spaces and punctuation​

4.​ Compare 'm' and 'm' → equal → move pointers​

5.​ Continue process until left >= right​

6.​ ✅ All matches → return true​

📊 Complexity Analysis
Operation Time Space

Two-pointer traversal O(n) n = length of string

Character checks O(1) per —

character
Total Time O(n) O(1)

Space O(1) Only pointers used, no extra

arrays

⚙️ Edge Cases
Case Input Output Explanation

Empty string "" true Empty string is palindrome

All non-alphanumeric "!!" true Ignored → empty → palindrome

Mixed case "Aa" true Case-insensitive check

Spaces & "race a false Not a palindrome after filtering

punctuation car"

🧩 Key Takeaways
●​ Pattern: Two-pointer string validation​

●​ Core Idea: Move from both ends, skip invalid characters, compare remaining​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

●​ Common mistakes:​

○​ Not skipping non-alphanumeric​

○​ Not ignoring case​

✅ Final Answer Summary

●​ Approach: Two-pointer with alphanumeric filtering​

●​ Time: O(n)​

●​ Space: O(1)​
 ●​ Pattern: Two-pointer string manipulation​

Great ✅ ​
Let’s move on to Two Pointers – Problem 2: Two Sum II (Input Array Is Sorted), a
classic variation of the Two Sum problem optimized for sorted arrays.

🧩 Two Pointers – Problem 2: Two Sum II

📝 Problem Statement
Given a 1-indexed array of integers numbers that is already sorted in ascending order,
find two numbers such that they add up to a specific target.

Return the indices of the two numbers as an array [index1, index2], where 1 <=
index1 < index2 <= numbers.length.

●​ You may assume that exactly one solution exists.​

●​ You may not use the same element twice.​

●​ Must use O(1) extra space.​

🔹 Examples
Example 1:

Input: numbers = [2,7,11,15], target = 9

Output: [1,2]

Explanation: 2 + 7 = 9

Example 2:

Input: numbers = [2,3,4], target = 6

Output: [1,3]
Explanation: 2 + 4 = 6

Example 3:

Input: numbers = [-1,0], target = -1

Output: [1,2]

💡 Intuition
●​ Array is sorted, so we can use two pointers:​

○​ Start left at index 0​

○​ Start right at index n-1​

●​ Compute sum = numbers[left] + numbers[right]​

○​ If sum == target → return indices​

○​ If sum < target → increment left (need larger sum)​

○​ If sum > target → decrement right (need smaller sum)​

●​ Continue until solution is found (guaranteed to exist)​

💻 Java Code
import java.util.*;

public class TwoSumII {

public static int[] twoSum(int[] numbers, int target) {

int left = 0, right = numbers.length - 1;

 while (left < right) {

int sum = numbers[left] + numbers[right];

if (sum == target) {

// 1-indexed requirement

return new int[]{left + 1, right + 1};

} else if (sum < target) {

left++;

} else {

right--;

// As per problem, exactly one solution exists

return new int[]{-1, -1};

// Driver code

public static void main(String[] args) {

int[] numbers1 = {2,7,11,15};

int target1 = 9;

System.out.println(Arrays.toString(twoSum(numbers1, target1))); //
[1,2]

int[] numbers2 = {2,3,4};

 int target2 = 6;

System.out.println(Arrays.toString(twoSum(numbers2, target2))); //
[1,3]

🔍 Dry Run Example

Input: [2,7,11,15], target = 9

Ste left right sum Action

p

1 0 3 2+15=17 sum>9 → right--

2 0 2 2+11=13 sum>9 → right--

3 0 1 2+7=9 sum==target → return [1,2]

✅ Output: [1,2]

📊 Complexity Analysis
Operation Time Space

Two-pointer traversal O(n) left & right pointers only

Total Time O(n) O(1)

Space O(1) No extra data structures

⚙️ Edge Cases
Case Input Output

Negative numbers [-3, -1, 2, 4] target=1 [2,4]

Only two elements [1,2] target=3 [1,2]

Large numbers [1,2,3,1000000] [3,4]

target=1000002

🧩 Key Takeaways
●​ Pattern: Two-pointer technique on sorted array​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

●​ Why efficient: No need for HashMap due to sorted array​

●​ Common mistake: Forgetting to return 1-indexed values​

✅ Final Answer Summary

●​ Approach: Two pointers moving inward​

●​ Time: O(n)​

●​ Space: O(1)​
 ●​ Pattern: Sorted array → two-pointer sum search​

Perfect 🔥 ​
Here’s the next problem in order:

Problem 12: 3Sum (Overall count: 12/150)

📝 Problem Statement
Given an integer array nums, return all unique triplets [nums[i], nums[j], nums[k]]
such that:

nums[i] + nums[j] + nums[k] == 0

●​ The solution set must not contain duplicate triplets.​

🔹 Examples
Example 1:

Input: nums = [-1,0,1,2,-1,-4]

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

Example 2:

Input: nums = []

Output: []

Example 3:

Input: nums = [0]

Output: []

💡 Intuition
●​ Find three numbers summing to 0.​

●​ Sorting the array allows us to use the two-pointer technique efficiently:​

○​ Fix one number nums[i]​

○​ Use two pointers left and right for the remaining two numbers​

○​ Move pointers inward based on the sum​

●​ Skip duplicates to avoid repeating triplets.​

🧠 Approach (Sorting + Two Pointers)

1.​ Sort the array.​

2.​ Loop i from 0 to n-3:​

○​ If i > 0 and nums[i] == nums[i-1] → skip (avoid duplicates)​

○​ Initialize left = i+1, right = n-1​

3.​ While left < right:​

○​ Compute sum = nums[i] + nums[left] + nums[right]​

○​ If sum == 0 → add [nums[i], nums[left], nums[right]] to result​

■​ Increment left and decrement right, skip duplicates​

○​ If sum < 0 → increment left​

○​ If sum > 0 → decrement right​

 4.​ Return the result list​

💻 Java Code
import java.util.*;

public class ThreeSum {

public static List<List<Integer>> threeSum(int[] nums) {

List<List<Integer>> res = new ArrayList<>();

Arrays.sort(nums);

for (int i = 0; i < nums.length - 2; i++) {

if (i > 0 && nums[i] == nums[i - 1])

continue; // skip duplicates

int left = i + 1;

int right = nums.length - 1;

while (left < right) {

int sum = nums[i] + nums[left] + nums[right];

if (sum == 0) {

res.add(Arrays.asList(nums[i], nums[left], nums[right]));

left++;

right--;
 // Skip duplicates

while (left < right && nums[left] == nums[left - 1])

left++;

while (left < right && nums[right] == nums[right + 1])

right--;

} else if (sum < 0) {

left++;

} else {

right--;

return res;

// Driver code

public static void main(String[] args) {

int[] nums = { -1, 0, 1, 2, -1, -4 };

System.out.println(threeSum(nums)); // [[-1,-1,2],[-1,0,1]]

🔍 Dry Run Example

Input: [-1, 0, 1, 2, -1, -4] → after sorting: [-4, -1, -1, 0, 1, 2]

i nums[i] left right sum Action

0 -4 1 5 -4+(-1)+2=-3 sum<0 → left++

0 -4 2 5 -4+(-1)+2=-3 left++

0 -4 3 5 -4+0+2=-2 left++

0 -4 4 5 -4+1+2=-1 left++

1 -1 2 5 -1+(-1)+2=0 add triplet [-1,-1,2], move pointers

1 -1 3 4 -1+0+1=0 add triplet [-1,0,1], move pointers

✅ Result: [[-1,-1,2], [-1,0,1]]

📊 Complexity Analysis
Step Time Space

Sorting O(n log n) O(log n) (recursive stack)

Loop + two pointers O(n^2) O(1) extra

Total Time O(n^2) O(1) (excluding result)

⚙️ Edge Cases
Case Input Output

Less than 3 [0,1] []

elements

All zeros [0,0,0, [[0,0,0

0] ]]

No triplet sums to 0 [1,2,3] []

🧩 Key Takeaways
●​ Pattern: Two pointers with sorting to handle 3Sum​

●​ Time Complexity: O(n^2) — optimal for 3Sum​

●​ Space Complexity: O(1) extra (result excluded)​

●​ Important: Skip duplicates carefully to avoid repeated triplets​

✅ Final Summary
●​ Approach: Sort + two pointers​

●​ Time: O(n^2)​

●​ Space: O(1)​

●​ Pattern: Two-pointer sum search with duplicate skipping​

Perfect✅ ​
Next up:
Problem 13: Container With Most Water (Overall count:
13/150)

📝 Problem Statement
You are given an array height of length n. Each element represents the height of a
vertical line at that index.

Find two lines that together with the x-axis form a container, such that the container holds
the most water.

Return the maximum area of water the container can contain.

●​ Area formula: area = min(height[i], height[j]) * (j - i)​

🔹 Examples
Example 1:

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

Output: 49

Explanation: Lines at index 1 and 8 → min(8,7)*(8-1)=49

Example 2:

Input: height = [1,1]

Output: 1

💡 Intuition
●​ Brute-force: Check all pairs → O(n²)​
 ●​ Optimized: Two-pointer approach:​

○​ Start with left=0, right=n-1​

○​ Compute area, move the shorter line inward (maybe we can increase height)​

○​ Repeat until left >= right​

Why move shorter line?

●​ Moving the taller line cannot increase area, because width decreases and height is
limited by the shorter line.​

●​ Moving the shorter line gives a chance to find a taller line → potentially larger area.​

💻 Java Code
public class ContainerWithMostWater {

public static int maxArea(int[] height) {

int left = 0, right = height.length - 1;

int maxArea = 0;

while (left < right) {

int area = Math.min(height[left], height[right]) * (right -

left);

maxArea = Math.max(maxArea, area);

// Move the shorter line

if (height[left] < height[right]) {

left++;

} else {
 right--;

return maxArea;

// Driver code

public static void main(String[] args) {

int[] height = {1,8,6,2,5,4,8,3,7};

System.out.println(maxArea(height)); // 49

🔍 Dry Run Example

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

1.​ left=0, right=8, area=min(1,7)*(8-0)=8 → max=8​

2.​ height[left]<height[right] → left++ → left=1​

3.​ left=1, right=8, area=min(8,7)*(8-1)=49 → max=49​

4.​ height[left]>height[right] → right-- → right=7​

5.​ Continue moving pointers → max remains 49​

✅ Final output: 49

📊 Complexity Analysis
 Step Time Space

Two-pointer traversal O(n) n = length of array

Total Time O(n) O(1)

Space O(1) Only pointers

used

⚙️ Edge Cases
Case Input Outpu Notes
t

Two [1,1] 1 Only one container possible

elements

All heights [5,5,5,5 15 Width matters

equal ]

Increasing [1,2,3,4 6 max between first and last → 1*4=4? wait check →
heights ,5] min(1,5)*4=4, middle? Yes, optimal choice

🧩 Key Takeaways
●​ Pattern: Two-pointer technique​

●​ Core Idea: Always move the shorter line to try maximizing area​

●​ Time Complexity: O(n)​

 ●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Two pointers moving inward, always move shorter line​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Two-pointer optimization for max/min problems​

Awesome ⚡
​
Next problem in order:

Problem 14: Trapping Rain Water (Overall count:

14/150)

📝 Problem Statement
Given n non-negative integers representing elevation heights of bars, compute how much
rainwater can be trapped after raining.

●​ The width of each bar is 1.​

●​ Return the total trapped water.​

🔹 Example
Example 1:

Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]

Output: 6
Explanation: Water trapped at each index → [0,0,1,0,1,2,1,0,0,1,0,0] → sum=6

Example 2:

Input: height = [4,2,0,3,2,5]

Output: 9

💡 Intuition
●​ Water trapped at index i depends on the tallest bar to the left and tallest bar to
the right:​

water[i] = min(maxLeft[i], maxRight[i]) - height[i]

●​ Two main approaches:​

1.​ Prefix and Suffix arrays → O(n) time, O(n) space​

2.​ Two-pointer approach → O(n) time, O(1) space​

🧠 Approach 1 — Prefix & Suffix Arrays

1.​ Compute maxLeft[i] = max height to the left of i​

2.​ Compute maxRight[i] = max height to the right of i​

3.​ Trapped water at i = min(maxLeft[i], maxRight[i]) - height[i]​

💻 Java Code — Prefix & Suffix

public class TrappingRainWater {
public static int trap(int[] height) {

int n = height.length;

if (n == 0)

return 0;

int[] leftMax = new int[n];

int[] rightMax = new int[n];

leftMax[0] = height[0];

for (int i = 1; i < n; i++) {

leftMax[i] = Math.max(leftMax[i - 1], height[i]);

rightMax[n - 1] = height[n - 1];

for (int i = n - 2; i >= 0; i--) {

rightMax[i] = Math.max(rightMax[i + 1], height[i]);

int trapped = 0;

for (int i = 0; i < n; i++) {

trapped += Math.min(leftMax[i], rightMax[i]) - height[i];

return trapped;

}
 // Driver code

public static void main(String[] args) {

int[] height = { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 };

System.out.println(trap(height)); // 6

🧠 Approach 2 — Two Pointers (Optimized)

●​ Maintain two pointers left and right​

●​ Keep track of leftMax and rightMax​

●​ At each step:​

○​ If height[left] < height[right] → process left, else → process right​

●​ Add trapped water on the fly​

●​ Space O(1), Time O(n)​

💻 Java Code — Two Pointers

public class TrappingRainWaterOptimized {

public static int trap(int[] height) {

int left = 0, right = height.length - 1;

int leftMax = 0, rightMax = 0;

int trapped = 0;

while (left < right) {

 if (height[left] < height[right]) {

if (height[left] >= leftMax) leftMax = height[left];

else trapped += leftMax - height[left];

left++;

} else {

if (height[right] >= rightMax) rightMax = height[right];

else trapped += rightMax - height[right];

right--;

return trapped;

// Driver code

public static void main(String[] args) {

int[] height = {0,1,0,2,1,0,1,3,2,1,2,1};

System.out.println(trap(height)); // 6

🔍 Dry Run Example

Input: [0,1,0,2,1,0,1,3,2,1,2,1]

●​ left=0, right=11​

●​ leftMax=0, rightMax=1, trapped=0​

●​ Process each side based on height[left] < height[right]​

 ●​ Update leftMax/rightMax and accumulate trapped water​

●​ Final trapped water = 6 ✅​

📊 Complexity Analysis
Approach Time Spac
e

Prefix & Suffix O(n) O(n)

Two Pointers O(n) O(1)

⚙️ Edge Cases
Case Input Output

Flat surface [1,1,1,1] 0

Single pit [0,2,0] 0

Multiple pits [4,2,0,3,2 9

,5]

🧩 Key Takeaways
●​ Pattern: Two pointers / prefix-suffix max arrays​

●​ Core Idea: Water trapped = min(maxLeft, maxRight) - height​

 ●​ Optimal Solution: Two-pointer, O(n) time, O(1) space​

✅ Final Summary
●​ Approach: Two pointers or prefix/suffix arrays​

●​ Time: O(n)​

●​ Space: O(1) (optimized)​

3. SLIDING WINDOW

Problem 15: Best Time to Buy and Sell Stock (Overall

count: 15/150)

📝 Problem Statement
You are given an array prices where prices[i] is the price of a stock on day i.

You want to maximize your profit by choosing a single day to buy and a later day to sell.

Return the maximum profit you can achieve. If no profit is possible, return 0.

🔹 Examples
Example 1:

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

Output: 5

Explanation: Buy on day 2 (price=1), sell on day 5 (price=6), profit=6-1=5

Example 2:

Input: prices = [7,6,4,3,1]

Output: 0

Explanation: No profitable transaction possible

💡 Intuition
●​ Need to find the maximum difference prices[j] - prices[i] where j > i.​

●​ Naively, check all pairs → O(n²)​

●​ Optimized approach:​

○​ Track minimum price seen so far​

○​ Compute profit if sold today = prices[i] - minPrice​

○​ Update maxProfit if current profit is higher​

💻 Java Code
public class BestTimeToBuySellStock {

public static int maxProfit(int[] prices) {

int minPrice = Integer.MAX_VALUE;

int maxProfit = 0;

for (int price : prices) {

if (price < minPrice) {

minPrice = price; // update minimum price

 } else {

maxProfit = Math.max(maxProfit, price - minPrice);

return maxProfit;

// Driver code

public static void main(String[] args) {

int[] prices1 = {7,1,5,3,6,4};

System.out.println(maxProfit(prices1)); // 5

int[] prices2 = {7,6,4,3,1};

System.out.println(maxProfit(prices2)); // 0

🔍 Dry Run Example

Input: [7,1,5,3,6,4]

Day Price minPrice Profit = price - minPrice maxProfit

0 7 7 0 0

1 1 1 0 0
2 5 1 4 4

3 3 1 2 4

4 6 1 5 5

5 4 1 3 5

✅ Max Profit = 5

📊 Complexity Analysis
Operation Time Space

Single pass O(n) n = length of prices

Tracking min and max O(1) —

Total Time O(n) O(1)

Space O(1) —

⚙️ Edge Cases
Case Input Output
 No profit possible [7,6,4,3, 0
1]

Increasing prices [1,2,3,4, 4

5]

Single day [5] 0

Empty array [] 0

🧩 Key Takeaways
●​ Pattern: Track minimum value, calculate potential profit​

●​ Core Idea: Max profit = current price - min price so far​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Single pass, track min price​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Min-tracking for max difference​

Perfect⚡ ​
Next problem in order:
Problem 16: Longest Substring Without Repeating
Characters (Overall count: 16/150)

📝 Problem Statement
Given a string s, find the length of the longest substring without repeating characters.

🔹 Examples
Example 1:

Input: s = "abcabcbb"

Output: 3

Explanation: The longest substring without repeating characters is "abc", length = 3

Example 2:

Input: s = "bbbbb"

Output: 1

Explanation: Longest substring = "b"

Example 3:

Input: s = "pwwkew"

Output: 3

Explanation: Longest substring = "wke"

💡 Intuition
 ●​ Need the longest substring with all unique characters​

●​ Use a sliding window / two pointers approach:​

○​ Maintain a window [left, right]​

○​ Expand right until a duplicate is found​

○​ Move left to skip the duplicate​

●​ Track max window length during traversal​

🧠 Approach (Sliding Window)

1.​ Initialize left = 0, maxLength = 0​

2.​ Use a HashSet to track characters in current window​

3.​ Loop right from 0 to s.length() - 1:​

○​ If s[right] already in set:​

■​ Remove s[left] from set​

■​ Increment left​

○​ Else:​

■​ Add s[right] to set​

■​ Update maxLength = max(maxLength, right - left + 1)​

4.​ Return maxLength​

💻 Java Code
import java.util.*;
public class LongestSubstringWithoutRepeating {

public static int lengthOfLongestSubstring(String s) {

Set<Character> set = new HashSet<>();

int left = 0, maxLength = 0;

for (int right = 0; right < s.length(); right++) {

char c = s.charAt(right);

while (set.contains(c)) {

set.remove(s.charAt(left));

left++;

set.add(c);

maxLength = Math.max(maxLength, right - left + 1);

return maxLength;

// Driver code

public static void main(String[] args) {

String s1 = "abcabcbb";

System.out.println(lengthOfLongestSubstring(s1)); // 3
 String s2 = "bbbbb";

System.out.println(lengthOfLongestSubstring(s2)); // 1

String s3 = "pwwkew";

System.out.println(lengthOfLongestSubstring(s3)); // 3

🔍 Dry Run Example

Input: "abcabcbb"

●​ Initialize left=0, set={}, maxLength=0​

●​ Right=0 → 'a' not in set → add → maxLength=1​

●​ Right=1 → 'b' → add → maxLength=2​

●​ Right=2 → 'c' → add → maxLength=3​

●​ Right=3 → 'a' in set → remove 'a' at left=0, left++ → add 'a'​

●​ Continue until end → maxLength = 3 ✅​

📊 Complexity Analysis
Step Time Space

Traverse string O(n) n = length of string

HashSet O(1) O(n)

operations average
Total Time O(n) O(n)

Space O(n) For storing characters in

set

⚙️ Edge Cases
Case Input Output

Empty string "" 0

Single char "a" 1

All same "aaaa" 1

chars

All unique "abcde 6

f"

🧩 Key Takeaways
●​ Pattern: Sliding window for substring problems​

●​ Core Idea: Expand window until duplicate → shrink from left​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

✅ Final Summary
 ●​ Approach: Sliding window with HashSet​

●​ Time: O(n)​

●​ Space: O(n)​

●​ Pattern: Two-pointer / sliding window substring​

Perfect⚡ ​
Next problem in order:

Problem 17: Longest Repeating Character Replacement

(Overall count: 17/150)

📝 Problem Statement
Given a string s consisting of uppercase letters and an integer k, you can replace at most k
characters with any uppercase letter to get the longest substring with the same letters.

Return the length of the longest substring possible after at most k replacements.

🔹 Examples
Example 1:

Input: s = "ABAB", k = 2

Output: 4

Explanation: Replace both 'A's with 'B's or vice versa → "BBBB" or "AAAA"

Example 2:

Input: s = "AABABBA", k = 1

Output: 4
Explanation: Replace one 'A' with 'B' → "AABBBBA", longest substring = "BBBB"

💡 Intuition
●​ Goal: Longest substring after at most k changes​

●​ Key observation:​

○​ Maintain a sliding window​

○​ Count frequency of letters in the current window​

○​ Let maxCount = frequency of most frequent letter in the window​

○​ Window size = right - left + 1​

○​ If (window size - maxCount) > k → we need more than k

replacements → shrink window​

🧠 Approach (Sliding Window with Frequency Map)

1.​ Use Map or array count[26] to store character counts​

2.​ Initialize left = 0, maxCount = 0, maxLength = 0​

3.​ Loop right over string:​

○​ Increment count of s[right]​

○​ Update maxCount = max(maxCount, count[s[right]])​

○​ If (right - left + 1) - maxCount > k → shrink window:​

■​ decrement count of s[left], left++​

○​ Update maxLength = max(maxLength, right - left + 1)​

4.​ Return maxLength​

💻 Java Code
public class LongestRepeatingCharReplacement {

public static int characterReplacement(String s, int k) {

int[] count = new int[26];

int left = 0, maxCount = 0, maxLength = 0;

for (int right = 0; right < s.length(); right++) {

count[s.charAt(right) - 'A']++;

maxCount = Math.max(maxCount, count[s.charAt(right) - 'A']);

while ((right - left + 1) - maxCount > k) {

count[s.charAt(left) - 'A']--;

left++;

maxLength = Math.max(maxLength, right - left + 1);

return maxLength;

// Driver code

public static void main(String[] args) {

String s1 = "ABAB";
 int k1 = 2;

System.out.println(characterReplacement(s1, k1)); // 4

String s2 = "AABABBA";

int k2 = 1;

System.out.println(characterReplacement(s2, k2)); // 4

🔍 Dry Run Example

Input: "AABABBA", k = 1

●​ Initialize left=0, maxCount=0, count[26]=0​

●​ Right=0 → 'A' → count[A]=1 → maxCount=1 → window size=1 → ok →

maxLength=1​

●​ Right=1 → 'A' → count[A]=2 → maxCount=2 → window size=2 → ok →

maxLength=2​

●​ Right=2 → 'B' → count[B]=1 → maxCount=2 → window size=3 → (3-2)=1 ≤ k → ok

→ maxLength=3​

●​ Right=3 → 'A' → count[A]=3 → maxCount=3 → window size=4 → (4-3)=1 ≤ k →

maxLength=4​

●​ Continue → final maxLength=4 ✅​

📊 Complexity Analysis
Step Time Space
Single pass O(n) n = length of string

Frequency O(1) O(26) ≈ O(1)

array

Total Time O(n) O(1)

Space O(1) Fixed array

⚙️ Edge Cases
Case Input Output

Empty string "", k=2 0

All same "AAAA", 4

k=2

k >= length "ABCD", 4

k=4

No "ABCD", 1
replacement k=0

🧩 Key Takeaways
●​ Pattern: Sliding window with frequency tracking​
 ●​ Core Idea: window size - maxCount = number of changes needed​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Sliding window + frequency array​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Sliding window with dynamic constraints​

Perfect⚡ ​
Next problem in order:

Problem 18: Permutation in String (Overall count:

18/150)

📝 Problem Statement
Given two strings s1 and s2, return true if s2 contains a permutation of s1.

In other words, one of the anagrams of s1 is a substring of s2.

🔹 Examples
Example 1:

Input: s1 = "ab", s2 = "eidbaooo"

Output: true
Explanation: s2 contains "ba", which is a permutation of s1

Example 2:

Input: s1 = "ab", s2 = "eidboaoo"

Output: false

💡 Intuition
●​ Need to check if any substring of s2 has the same character counts as s1​

●​ Sliding window of length s1.length() works efficiently:​

○​ Count frequency of chars in s1​

○​ Count frequency of chars in current window of s2​

○​ Compare counts​

●​ To optimize, maintain one array and a match count instead of comparing arrays
every time.​

🧠 Approach (Sliding Window + Frequency Count)

1.​ Create count[26] for s1​

2.​ Maintain a sliding window of size s1.length() over s2​

3.​ Update window counts dynamically​

4.​ If window count matches s1 count → return true​

5.​ Return false if no match found​

💻 Java Code
public class PermutationInString {

public static boolean checkInclusion(String s1, String s2) {

int[] s1Count = new int[26];

for (char c : s1.toCharArray()) s1Count[c - 'a']++;

int left = 0, right = 0, n = s2.length();

int[] windowCount = new int[26];

int len = s1.length();

while (right < n) {

// add current char

windowCount[s2.charAt(right) - 'a']++;

right++;

// shrink window if size > len

if (right - left > len) {

windowCount[s2.charAt(left) - 'a']--;

left++;

// check match

if (matches(s1Count, windowCount)) return true;

return false;
 }

private static boolean matches(int[] a, int[] b) {

for (int i = 0; i < 26; i++) {

if (a[i] != b[i]) return false;

return true;

// Driver code

public static void main(String[] args) {

String s1 = "ab", s2 = "eidbaooo";

System.out.println(checkInclusion(s1, s2)); // true

String s3 = "ab", s4 = "eidboaoo";

System.out.println(checkInclusion(s3, s4)); // false

🔍 Dry Run Example

Input: s1 = "ab", s2 = "eidbaooo"

●​ s1Count = [a=1, b=1]​

●​ Window size = 2​

●​ Slide window over s2:​

○​ "ei" → count mismatch​

 ○​ "id" → mismatch​

○​ "db" → mismatch​

○​ "ba" → count matches → return true ✅​

📊 Complexity Analysis
Step Time Space

Sliding window O(n) n = s2.length()

Compare O(26) → O(1) O(26) → O(1)

arrays

Total Time O(n) O(1)

Space O(1) Two arrays of size 26

⚙️ Edge Cases
Case Input Output

s1 longer than "abc", "ab" false

s2

Exact match "abc", "cab" true

 Repeating chars "aabc", true
"cbaaa"

🧩 Key Takeaways
●​ Pattern: Sliding window + fixed-size frequency array​

●​ Core Idea: Compare character counts in window of s2 with s1​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Sliding window of length s1 + frequency arrays​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Sliding window + character frequency​

Perfect⚡ ​
Next problem in order:

Problem 19: Minimum Window Substring (Overall

count: 19/150)

📝 Problem Statement
Given two strings s and t, find the minimum window substring in s that contains all
characters of t (including duplicates).
 ●​ If no such window exists, return an empty string "".​

🔹 Examples
Example 1:

Input: s = "ADOBECODEBANC", t = "ABC"

Output: "BANC"

Example 2:

Input: s = "a", t = "a"

Output: "a"

Example 3:

Input: s = "a", t = "aa"

Output: ""

💡 Intuition
●​ Need a substring covering all characters in t​

●​ Sliding window + hash map works efficiently:​

○​ Track count of characters in t​

○​ Expand window to include all chars​

○​ Shrink window to find minimum length​

●​ Classic variable-size sliding window problem​

🧠 Approach (Sliding Window + HashMap)
1.​ Count frequency of chars in t → Map<Character,Integer> tCount​

2.​ Initialize left = 0, right = 0, formed = 0, required = tCount.size()​

3.​ Use windowCounts to track chars in current window​

4.​ Expand right:​

○​ Add s[right] to windowCounts​

○​ If windowCount of s[right] matches tCount → increment formed​

5.​ While formed == required:​

○​ Update minimum window if smaller than previous​

○​ Remove s[left] from windowCounts → decrement formed if necessary​

○​ Increment left​

6.​ Return minimum window substring​

💻 Java Code
import java.util.*;

public class MinimumWindowSubstring {

public static String minWindow(String s, String t) {

// Edge case: empty strings

if (s.length() == 0 || t.length() == 0) return "";

// Step 1: Count the frequency of each character in t

 Map<Character, Integer> tCount = new HashMap<>();

for (char c : t.toCharArray()) {

tCount.put(c, tCount.getOrDefault(c, 0) + 1);

// Step 2: Sliding window counts

Map<Character, Integer> windowCount = new HashMap<>();

int left = 0, right = 0; // window boundaries

int formed = 0; // number of characters meeting

required frequency

int required = tCount.size(); // total unique characters in t to

match

int minLen = Integer.MAX_VALUE; // minimum window length

int minLeft = 0; // start index of minimum window

// Step 3: Expand the window with right pointer

while (right < s.length()) {

char c = s.charAt(right);

windowCount.put(c, windowCount.getOrDefault(c, 0) + 1);

// If current character meets frequency requirement in t

if (tCount.containsKey(c) &&

windowCount.get(c).intValue() == tCount.get(c).intValue()) {

formed++;

}
 // Step 4: Contract the window from left while all required
characters are present

while (left <= right && formed == required) {

// Update minimum window if smaller

if (right - left + 1 < minLen) {

minLen = right - left + 1;

minLeft = left;

// Remove the leftmost character from the window

char leftChar = s.charAt(left);

windowCount.put(leftChar, windowCount.get(leftChar) - 1);

// Check if this removal breaks the requirement

if (tCount.containsKey(leftChar) &&

windowCount.get(leftChar) < tCount.get(leftChar)) {

formed--;

// Move left pointer to shrink window

left++;

// Move right pointer to expand window

right++;

}
 // Step 5: Return the minimum window substring if found

return minLen == Integer.MAX_VALUE ? "" : s.substring(minLeft,

minLeft + minLen);

// Driver code to test the function

public static void main(String[] args) {

String s1 = "ADOBECODEBANC", t1 = "ABC";

System.out.println(minWindow(s1, t1)); // Output: "BANC"

String s2 = "a", t2 = "a";

System.out.println(minWindow(s2, t2)); // Output: "a"

String s3 = "a", t3 = "aa";

System.out.println(minWindow(s3, t3)); // Output: ""

🔍 Dry Run Example

Input: s = "ADOBECODEBANC", t = "ABC"

1.​ tCount = {A:1, B:1, C:1}, required = 3​

2.​ Expand window: "ADOBEC" → window contains A,B,C → formed=3​

3.​ Shrink from left → "DOBEC" → formed < required → stop​

4.​ Expand window → find smaller "BANC"​

 5.​ Return "BANC" ✅​

📊 Complexity Analysis
Step Time Space

Sliding window O(n) n = s.length()

HashMap O(1) per O(

operations char

Total Time O(n) O(n)

Space O( T

⚙️ Edge Cases
Case Input Output

No window "a", "aa" ""

Exact match "abc", "abc"

"abc"

Single char t "abc", "b" "b"

🧩 Key Takeaways
 ●​ Pattern: Variable-length sliding window + hashmap​

●​ Core Idea: Expand to cover → shrink to minimize​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(|S| + |T|)​

✅ Final Summary
●​ Approach: Sliding window + character counts​

●​ Time: O(n)​

●​ Space: O(|S| + |T|)​

●​ Pattern: Minimum window substring using hashmap​

✅ Explanation of Code
1.​ tCount: Stores required character counts from t.​

2.​ windowCount: Tracks counts of characters in current sliding window.​

3.​ formed: Number of unique characters in window that satisfy t’s frequency.​

4.​ Expand window: Increment right, add char to windowCount, check if it satisfies
requirement.​

5.​ Shrink window: While all required chars are present, try moving left to minimize
window.​

6.​ Update minimum: Keep track of smallest window length and start index.​

7.​ Return result: Substring from minLeft of length minLen.​

🔍 Complexity Analysis
 Step Time Space

Sliding window O(n) n = s.length()

HashMap O(1) per O(

operations char

Total Time O(n) O(

Space O( S

Perfect ⚡
​
Next problem in order:

Problem 20: Sliding Window Maximum (Overall count:

20/150)

📝 Problem Statement
Given an integer array nums and an integer k, there is a sliding window of size k which
moves from the very left to the very right of the array.

●​ You can only see the k numbers in the window.​

●​ Return an array of the maximum values in each window.​

🔹 Examples
Example 1:
Input: nums = [1,3,-1,-3,5,3,6,7], k = 3

Output: [3,3,5,5,6,7]

Example 2:

Input: nums = [1], k = 1

Output: [1]

💡 Intuition
●​ Brute-force: Check maximum in each window → O(n*k)​

●​ Optimized: Use Deque to maintain indices of elements in decreasing order:​

○​ Front of deque → maximum of current window​

○​ Remove indices out of window​

○​ Remove indices smaller than current element (they cannot be maximum)​

🧠 Approach (Deque)
1.​ Use a deque to store indices in decreasing order of values.​

2.​ Loop through nums:​

○​ Remove indices out of current window (i - k)​

○​ Remove indices of elements smaller than current element​

○​ Add current index to deque​

○​ If window is formed (i >= k-1), record nums[deque.peekFirst()] as

maximum​
💻 Java Code with Comments
import java.util.*;

public class SlidingWindowMaximum {

public static int[] maxSlidingWindow(int[] nums, int k) {

if (nums == null || k <= 0) return new int[0];

int n = nums.length;

int[] result = new int[n - k + 1]; // array to store max of each

window

int ri = 0; // result index

Deque<Integer> deque = new LinkedList<>(); // stores indices of

elements

for (int i = 0; i < n; i++) {

// Step 1: Remove indices which are out of the current window

while (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {

deque.pollFirst();

// Step 2: Remove indices whose values are less than nums[i]

// because they cannot be maximum in this window or future

windows

while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {

deque.pollLast();

}
 // Step 3: Add current index to deque

deque.offerLast(i);

// Step 4: Record maximum for the window

// Window is fully formed when i >= k - 1

if (i >= k - 1) {

result[ri++] = nums[deque.peekFirst()];

return result;

// Driver code

public static void main(String[] args) {

int[] nums = {1,3,-1,-3,5,3,6,7};

int k = 3;

System.out.println(Arrays.toString(maxSlidingWindow(nums, k)));

// Output: [3, 3, 5, 5, 6, 7]

int[] nums2 = {1};

int k2 = 1;

System.out.println(Arrays.toString(maxSlidingWindow(nums2, k2)));

// Output: [1]

}
}

🔍 Dry Run Example

Input: nums = [1,3,-1,-3,5,3,6,7], k = 3

i Window Deque Maximum

Indices

0 [1] [0] -

1 [1,3] [1] -

2 [1,3,-1] [1,2] 3

3 [3,-1,-3] [1,3] 3

4 [-1,-3,5] [4] 5

5 [-3,5,3] [4,5] 5

6 [5,3,6] [6] 6

7 [3,6,7] [7] 7

✅ Output: [3,3,5,5,6,7]

📊 Complexity Analysis
 Step Time Space

Traverse array once O(n) n = nums.length

Deque operations (each index O(1) O(k)

added/removed once) amortized

Total Time O(n) O(k)

Space O(k) Deque stores at most k

elements

⚙️ Edge Cases
Case Input Output

Single element [1], k=1 [1]

All same [2,2,2], [2,2]

k=2

k=1 [4,3,5], [4,3,

k=1 5]

🧩 Key Takeaways
●​ Pattern: Sliding window maximum using deque​

●​ Core Idea: Maintain decreasing sequence of indices, front = maximum​

 ●​ Time Complexity: O(n)​

●​ Space Complexity: O(k)​

✅ Final Summary
●​ Approach: Sliding window + deque​

●​ Time: O(n)​

●​ Space: O(k)​

●​ Pattern: Monotonic queue for maximum in sliding window​

4. STACKS

Problem 21: Valid Parentheses (Overall count: 21/150)

📝 Problem Statement
Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine
if the input string is valid.

A string is valid if:

1.​ Open brackets are closed by the same type of brackets.​

2.​ Open brackets are closed in the correct order.​

3.​ Every close bracket has a corresponding open bracket.​

🔹 Examples
Example 1:
Input: s = "()"

Output: true

Example 2:

Input: s = "()[]{}"

Output: true

Example 3:

Input: s = "(]"

Output: false

💡 Intuition
●​ Use a stack to track open brackets.​

●​ For each character:​

○​ If it’s an open bracket, push it onto the stack.​

○​ If it’s a close bracket, check if the top of stack is the matching open
bracket.​

■​ If yes → pop it.​

■​ If no → invalid.​

●​ At the end, stack should be empty for a valid string.​

💻 Java Code with Comments

import java.util.*;
public class ValidParentheses {

public static boolean isValid(String s) {

// Stack to store open brackets

Stack<Character> stack = new Stack<>();

for (char c : s.toCharArray()) {

// If open bracket, push corresponding closing bracket to stack

if (c == '(') stack.push(')');

else if (c == '{') stack.push('}');

else if (c == '[') stack.push(']');

// If closing bracket

else {

// If stack is empty or top doesn't match current char →

invalid

if (stack.isEmpty() || stack.pop() != c) return false;

// Valid if stack is empty at the end

return stack.isEmpty();

// Driver code

public static void main(String[] args) {

String s1 = "()";
 System.out.println(isValid(s1)); // true

String s2 = "()[]{}";

System.out.println(isValid(s2)); // true

String s3 = "(]";

System.out.println(isValid(s3)); // false

String s4 = "([{}])";

System.out.println(isValid(s4)); // true

🔍 Dry Run Example

Input: "([{}])"

1.​ Stack = []​

2.​ '(' → push ')' → Stack = [')']​

3.​ '[' → push ']' → Stack = [')',']']​

4.​ '{' → push '}' → Stack = [')',']','}']​

5.​ '}' → matches top → pop → Stack = [')',']']​

6.​ ']' → matches top → pop → Stack = [')']​

7.​ ')' → matches top → pop → Stack = [] ✅​

●​ Stack empty → valid​
📊 Complexity Analysis
Step Time Space

Traverse string O(n) n = s.length()

once

Stack operations O(1) O(n) in worst case

Total Time O(n) O(n)

Space O(n) For stack

⚙️ Edge Cases
Case Input Output

Empty string "" true

Single open "(" false

Single close ")" false

Nested "({[]} true

brackets )"

Wrong order "([)]" false

🧩 Key Takeaways
●​ Pattern: Stack for matching parentheses​

●​ Core Idea: Push expected closing brackets, pop when matched​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: Stack-based matching​

●​ Time: O(n)​

●​ Space: O(n)​

●​ Pattern: Classic parentheses validation​

Perfect⚡ ​
Next problem in order:

Problem 22: Min Stack (Overall count: 22/150)

📝 Problem Statement
Design a stack that supports push, pop, top, and retrieving the minimum element in
constant time.

Implement the MinStack class:

1.​ MinStack() initializes the stack.​

2.​ void push(int val) pushes the element val onto the stack.​

3.​ void pop() removes the element on top of the stack.​

 4.​ int top() gets the top element of the stack.​

5.​ int getMin() retrieves the minimum element in the stack.​

🔹 Examples
Example 1:

Input

["MinStack","push","push","push","getMin","pop","top","getMin"]

[[],[-2],[0],[-3],[],[],[],[]]

Output

[null,null,null,null,-3,null,0,-2]

Explanation:

●​ Push -2, 0, -3​

●​ getMin() → -3​

●​ pop() → removes -3​

●​ top() → 0​

●​ getMin() → -2​

💡 Intuition
●​ Regular stack → O(1) push/pop/top, but getMin is O(n)​

●​ Solution: Maintain a secondary stack minStack to track current minimums:​

○​ When pushing:​

■​ Push onto main stack​

 ■​ Push onto minStack if it's empty or val ≤ minStack.top()​

○​ When popping:​

■​ Pop from main stack​

■​ If popped value = minStack.top(), pop minStack too​

●​ getMin() → return minStack.top() in O(1)​

💻 Java Code with Comments

import java.util.*;

class MinStack {

private Stack<Integer> stack; // main stack

private Stack<Integer> minStack; // stack to track minimums

/** Initialize your data structure here. */

public MinStack() {

stack = new Stack<>();

minStack = new Stack<>();

/** Push element onto stack. */

public void push(int val) {

stack.push(val);

// Push onto minStack if empty or new val <= current min

if (minStack.isEmpty() || val <= minStack.peek()) {

minStack.push(val);
 }

/** Removes the element on top of the stack. */

public void pop() {

int val = stack.pop();

// If popped value is minimum, pop from minStack as well

if (val == minStack.peek()) {

minStack.pop();

/** Get the top element. */

public int top() {

return stack.peek();

/** Retrieve the minimum element in the stack. */

public int getMin() {

return minStack.peek();

// Driver code to test MinStack

public static void main(String[] args) {

MinStack minStack = new MinStack();

minStack.push(-2);
 minStack.push(0);

minStack.push(-3);

System.out.println(minStack.getMin()); // -3

minStack.pop();

System.out.println(minStack.top()); // 0

System.out.println(minStack.getMin()); // -2

🔍 Dry Run Example

1.​ Push -2 → stack=[-2], minStack=[-2]​

2.​ Push 0 → stack=[-2,0], minStack=[-2]​

3.​ Push -3 → stack=[-2,0,-3], minStack=[-2,-3]​

4.​ getMin() → -3 (top of minStack)​

5.​ Pop → removes -3 → stack=[-2,0], minStack=[-2]​

6.​ top() → 0​

7.​ getMin() → -2​

📊 Complexity Analysis
Operation Time Space

push O(1) O(1) per element

pop O(1) O(1)

top O(1) O(1)

getMin O(1) O(1)

Space — O(n) for two stacks

⚙️ Edge Cases
Case Description

Single element Stack of size 1 → getMin = element

Multiple mins Multiple identical min values → minStack tracks duplicates

Pop min After popping min, new min = next top of minStack

🧩 Key Takeaways
●​ Pattern: Stack with auxiliary stack for tracking extra info​

●​ Core Idea: Use minStack to maintain current minimums​

●​ Time Complexity: O(1) per operation​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: Two stacks → main stack + minStack​
 ●​ Time: O(1) push/pop/top/getMin​

●​ Space: O(n)​

●​ Pattern: Stack with auxiliary structure​

Perfect ⚡​
Next problem in order:

Problem 23: Evaluate Reverse Polish Notation (Overall

count: 23/150)

📝 Problem Statement
Given an array of strings tokens representing an arithmetic expression in Reverse
Polish Notation (RPN), evaluate the expression and return the result.

●​ Valid operators: +, -, *, /​

●​ Each operand may be an integer or another expression.​

●​ Division between two integers should truncate toward zero.​

🔹 Examples
Example 1:

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

Output: 9

Explanation: ((2 + 1) * 3) = 9

Example 2:

Input: tokens = ["4","13","5","/","+"]

Output: 6

Explanation: (4 + (13 / 5)) = 6

Example 3:

Input: tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]

Output: 22

💡 Intuition
●​ RPN = postfix notation → operators come after operands​

●​ Use a stack:​

○​ Push numbers onto the stack​

○​ When an operator is encountered:​

■​ Pop the top two numbers​

■​ Apply the operator​

■​ Push result back​

●​ At the end, stack contains final result​

💻 Java Code with Comments

import java.util.*;

public class EvaluateRPN {

public static int evalRPN(String[] tokens) {

Stack<Integer> stack = new Stack<>();

 for (String token : tokens) {

// If token is an operator

if (token.equals("+") || token.equals("-") || token.equals("*")

|| token.equals("/")) {

int b = stack.pop(); // second operand

int a = stack.pop(); // first operand

int res = 0;

switch (token) {

case "+": res = a + b; break;

case "-": res = a - b; break;

case "*": res = a * b; break;

case "/": res = a / b; break; // integer division

stack.push(res); // push result back

} else {

// Token is a number, push onto stack

stack.push(Integer.parseInt(token));

return stack.pop(); // final result

}
 // Driver code

public static void main(String[] args) {

String[] tokens1 = {"2","1","+","3","*"};

System.out.println(evalRPN(tokens1)); // 9

String[] tokens2 = {"4","13","5","/","+"};

System.out.println(evalRPN(tokens2)); // 6

String[] tokens3 =
{"10","6","9","3","+","-11","*","/","*","17","+","5","+"};

System.out.println(evalRPN(tokens3)); // 22

🔍 Dry Run Example

Input: ["2","1","+","3","*"]

1.​ Push 2 → stack=[2]​

2.​ Push 1 → stack=[2,1]​

3.​ '+' → pop 1,2 → compute 2+1=3 → push 3 → stack=[3]​

4.​ Push 3 → stack=[3,3]​

5.​ '' → pop 3,3 → compute 33=9 → push 9 → stack=[9]​

6.​ Final result = 9 ✅​

📊 Complexity Analysis
 Operation Time Space

Traverse tokens O(n) n = tokens.length

Stack O(1) O(n)

operations

Total Time O(n) O(n)

Space O(n) Stack stores

operands

⚙️ Edge Cases
Case Input Output

Single number ["42"] 42

Negative ["-4","2","/"] -2
numbers

Large expression ["10","6","9","3","+","-11","","/","","17","+","5","+"] 22

🧩 Key Takeaways
●​ Pattern: Stack for evaluating postfix expressions​

●​ Core Idea: Push numbers, pop for operator, push result​

 ●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: Stack-based evaluation of Reverse Polish Notation​

●​ Time: O(n)​

●​ Space: O(n)​

●​ Pattern: Stack for expression evaluation​

Perfect ⚡
​
Next problem in order:

Problem 24: Generate Parentheses (Overall count:

24/150)

📝 Problem Statement
Given n pairs of parentheses, generate all combinations of well-formed parentheses.

🔹 Examples
Example 1:

Input: n = 3

Output: ["((()))","(()())","(())()","()(())","()()()"]

Example 2:
Input: n = 1

Output: ["()"]

💡 Intuition
●​ Problem requires all valid combinations → use backtracking / DFS​

●​ At each step, we can:​

○​ Add '(' if open < n​

○​ Add ')' if close < open​

●​ Stop recursion when length = 2*n → add to results​

🧠 Approach (Backtracking)
1.​ Initialize result list.​

2.​ Define recursive function backtrack(current, open, close, n):​

○​ If current.length() == 2*n → add to result​

○​ If open < n → backtrack(current+'(', open+1, close, n)​

○​ If close < open → backtrack(current+')', open, close+1, n)​

3.​ Call backtrack("", 0, 0, n)​

4.​ Return result​

💻 Java Code with Comments

import java.util.*;
public class GenerateParentheses {

public static List<String> generateParenthesis(int n) {

List<String> result = new ArrayList<>();

backtrack(result, "", 0, 0, n);

return result;

private static void backtrack(List<String> result, String current, int

open, int close, int n) {

// If current string is complete

if (current.length() == 2 * n) {

result.add(current);

return;

// Add '(' if we can

if (open < n) {

backtrack(result, current + "(", open + 1, close, n);

// Add ')' if we can

if (close < open) {

backtrack(result, current + ")", open, close + 1, n);

}
 // Driver code

public static void main(String[] args) {

int n1 = 3;

System.out.println(generateParenthesis(n1));

// Output: ["((()))","(()())","(())()","()(())","()()()"]

int n2 = 1;

System.out.println(generateParenthesis(n2));

// Output: ["()"]

🔍 Dry Run Example

Input: n = 2

1.​ Start: current="" open=0 close=0​

2.​ Add '(' → current="(" open=1 close=0​

3.​ Add '(' → current="((" open=2 close=0​

4.​ Add ')' → current="(()" open=2 close=1​

5.​ Add ')' → current="(())" open=2 close=2 → add to result​

6.​ Backtrack → current="()" → add remaining combinations → result=["(())","()()"]​

📊 Complexity Analysis
 Step Time Space

Generate all O(4^n / sqrt(n)) Catalan number

sequences Cn

Recursion stack O(n) Max depth = n

Total Time O(4^n / sqrt(n)) O(n)

⚙️ Edge Cases
Case Input Output

n=0 0 []

n=1 1 ["()"]

Larger n 4 ["(((())))","((()()))",...]

🧩 Key Takeaways
●​ Pattern: Backtracking / DFS​

●​ Core Idea: Maintain valid open/close counts​

●​ Time Complexity: Catalan number → O(4^n / sqrt(n))​

●​ Space Complexity: O(n) recursion stack​

✅ Final Summary
●​ Approach: Backtracking with open/close counts​

●​ Time: O(4^n / sqrt(n))​

●​ Space: O(n) recursion stack​

●​ Pattern: Generate all valid sequences​

Perfect ⚡​
Next problem in order:

Problem 25: Daily Temperatures (Overall count: 25/150)

📝 Problem Statement
Given an array of integers temperatures representing daily temperatures, return an array
answer such that:

●​ answer[i] = number of days you have to wait after the i-th day to get a warmer
temperature.​

●​ If there is no future day for which this is possible, put 0 instead.​

🔹 Examples
Example 1:

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

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

Example 2:

Input: temperatures = [30,40,50,60]

Output: [1,1,1,0]

Example 3:

Input: temperatures = [30,60,90]

Output: [1,1,0]

💡 Intuition
●​ For each day, find the next day with higher temperature → next greater element
problem​

●​ Use a monotonic decreasing stack to store indices:​

○​ While current temp > stack top → pop and compute difference​

●​ At the end, indices remaining → no warmer day → 0​

🧠 Approach (Monotonic Stack)

1.​ Initialize stack to store indices​

2.​ Initialize answer array with 0s​

3.​ Loop through temperatures:​

○​ While stack not empty and current temp > temp[stack.peek()]:​

■​ Pop index → answer[pop] = currentIndex - pop​

○​ Push current index to stack​

4.​ Return answer​

💻 Java Code with Comments

import java.util.*;

public class DailyTemperatures {

public static int[] dailyTemperatures(int[] temperatures) {

int n = temperatures.length;

int[] answer = new int[n];

Stack<Integer> stack = new Stack<>(); // stores indices

for (int i = 0; i < n; i++) {

// While current temp is higher than temp at index on top of

stack

while (!stack.isEmpty() && temperatures[i] >

temperatures[stack.peek()]) {

int idx = stack.pop();

answer[idx] = i - idx; // number of days to wait

stack.push(i); // push current index

// Remaining indices in stack → no warmer day → answer already 0

return answer;

// Driver code

public static void main(String[] args) {

int[] temps1 = {73,74,75,71,69,72,76,73};

 System.out.println(Arrays.toString(dailyTemperatures(temps1)));

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

int[] temps2 = {30,60,90};

System.out.println(Arrays.toString(dailyTemperatures(temps2)));

// Output: [1,1,0]

🔍 Dry Run Example

Input: [73,74,75,71,69,72,76,73]

●​ i=0 → stack=[] → push 0 → stack=[0]​

●​ i=1 → 74>73 → pop 0 → answer[0]=1 → push 1 → stack=[1]​

●​ i=2 → 75>74 → pop 1 → answer[1]=1 → push 2 → stack=[2]​

●​ i=3 → 71 < 75 → push 3 → stack=[2,3]​

●​ i=4 → 69 < 71 → push 4 → stack=[2,3,4]​

●​ i=5 → 72>69 → pop4 → answer[4]=1, 72>71 → pop3 → answer[3]=2 → push5 →

stack=[2,5]​

●​ i=6 → 76>72 → pop5 → answer[5]=1, 76>75 → pop2 → answer[2]=4 → push6 →

stack=[6]​

●​ i=7 → 73<76 → push7 → stack=[6,7]​

●​ Remaining → answer[6]=0, answer[7]=0​

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

📊 Complexity Analysis
 Operation Time Space

Traverse temperatures O(n) n=

temperatures.length

Stack push/pop each index O(n) O(n)

once

Total Time O(n) O(n)

Space O(n) Stack stores indices

⚙️ Edge Cases
Case Input Output

Increasing temps [30,40,50] [1,1,0]

Decreasing [50,40,30] [0,0,0]

temps

Single element [100] [0]

🧩 Key Takeaways
●​ Pattern: Monotonic stack (next greater element)​

●​ Core Idea: Track indices with decreasing values, update when higher temp appears​
 ●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: Monotonic stack storing indices​

●​ Time: O(n)​

●​ Space: O(n)​

●​ Pattern: Next greater element in array

Perfect⚡ ​
Next problem in order:

Problem 26: Car Fleet (Overall count: 26/150)

📝 Problem Statement
There are n cars going to the same destination along a one-lane road.

●​ You are given two integer arrays position and speed of length n:​

○​ position[i] = position of the i-th car​

○​ speed[i] = speed of the i-th car​

●​ The destination is at target miles away.​

A car fleet is some non-empty set of cars driving at the same speed, where no car can pass
another.

●​ A car fleet arrives at the destination together.​

●​ Return the number of car fleets that will arrive at the destination.​
🔹 Examples
Example 1:

Input: target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]

Output: 3

Example 2:

Input: target = 10, position = [3], speed = [3]

Output: 1

💡 Intuition
●​ Cars cannot pass, but faster cars may catch slower ones → form a fleet​

●​ Sort cars by starting position descending (closest to target first)​

●​ Compute time to reach target for each car: time = (target - pos) / speed​

●​ Traverse cars:​

○​ If car behind reaches later than car ahead → forms new fleet​

○​ Else → merges with fleet ahead​

🧠 Approach (Sort + Stack)

1.​ Pair cars with (position[i], speed[i])​

2.​ Sort cars by position descending​

3.​ Initialize stack to store fleet arrival times​

4.​ Loop through cars:​

 ○​ Compute time = (target - pos) / speed​

○​ If stack empty or time > stack.peek() → push new fleet​

○​ Else → car joins fleet ahead​

5.​ Return stack.size() → number of fleets​

💻 Java Code with Comments

import java.util.*;

public class CarFleet {

public static int carFleet(int target, int[] position, int[] speed) {

int n = position.length;

// Pair positions with speed

int[][] cars = new int[n][2];

for (int i = 0; i < n; i++) {

cars[i][0] = position[i];

cars[i][1] = speed[i];

// Sort cars by position descending (closest to target first)

Arrays.sort(cars, (a,b) -> b[0] - a[0]);

Stack<Double> stack = new Stack<>();

for (int i = 0; i < n; i++) {

 double time = (double)(target - cars[i][0]) / cars[i][1];

// If current car takes longer than fleet ahead → new fleet

if (stack.isEmpty() || time > stack.peek()) {

stack.push(time);

// Else → merges with fleet ahead, do nothing

return stack.size(); // number of fleets

// Driver code

public static void main(String[] args) {

int target1 = 12;

int[] position1 = {10,8,0,5,3};

int[] speed1 = {2,4,1,1,3};

System.out.println(carFleet(target1, position1, speed1)); // 3

int target2 = 10;

int[] position2 = {3};

int[] speed2 = {3};

System.out.println(carFleet(target2, position2, speed2)); // 1

}
🔍 Dry Run Example
Input: target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]

1.​ Cars sorted by position: [(10,2),(8,4),(5,1),(3,3),(0,1)]​

2.​ Compute time to target:​

○​ 10 → (12-10)/2 = 1​

○​ 8 → (12-8)/4 = 1​

○​ 5 → (12-5)/1 = 7​

○​ 3 → (12-3)/3 = 3​

○​ 0 → (12-0)/1 = 12​

3.​ Traverse:​

○​ 10 → stack empty → push 1​

○​ 8 → 1 ≤ stack.peek() → joins fleet ahead​

○​ 5 → 7 > 1 → new fleet → push 7​

○​ 3 → 3 ≤ 7 → joins fleet ahead​

○​ 0 → 12 > 7 → new fleet → push 12​

4.​ Stack = [1,7,12] → 3 fleets ✅​

📊 Complexity Analysis
Step Time Space

Sorting cars O(n log n) O(n)

Traverse O(n) O(n) stack

cars
Total Time O(n log n) O(n)

Space O(n) Stack stores fleet

times

⚙️ Edge Cases
Case Input Output

Single car [3], speed=[3], target=10 1

All cars same [1,2,3], speed=[1,1,1] 3

speed

Cars catch up [0,2,4], speed=[4,2,1], target=10 1

🧩 Key Takeaways
●​ Pattern: Sort + Stack to track fleets​

●​ Core Idea: Faster cars catch slower ones → merge fleets​

●​ Time Complexity: O(n log n) for sorting​

●​ Space Complexity: O(n) for stack​

✅ Final Summary
●​ Approach: Sort by position descending + track fleet arrival times​

●​ Time: O(n log n)​

 ●​ Space: O(n)​

●​ Pattern: Stack for merging sequences based on time​

Perfect ⚡​
Next problem in order:

Problem 27: Largest Rectangle in Histogram (Overall

count: 27/150)

📝 Problem Statement
Given an array of integers heights representing the height of bars in a histogram, return
the area of the largest rectangle in the histogram.

●​ Width of each bar = 1​

🔹 Examples
Example 1:

Input: heights = [2,1,5,6,2,3]

Output: 10

Explanation: Rectangle of height 5 and 6 → width 2 → area = 10

Example 2:

Input: heights = [2,4]

Output: 4
💡 Intuition
●​ Brute-force: Check all pairs → O(n²) → too slow​

●​ Optimized: Use monotonic stack to find:​

○​ Next smaller bar to the left​

○​ Next smaller bar to the right​

●​ Rectangle height = bar height​

●​ Rectangle width = rightIndex - leftIndex - 1​

🧠 Approach (Monotonic Stack)

1.​ Initialize stack to store indices in increasing height order​

2.​ Loop through heights + extra 0 at end to pop all bars:​

○​ While current bar < stack top → pop → calculate area​

○​ Width = currentIndex - previousIndex - 1​

○​ Update maxArea​

3.​ Return maxArea​

💻 Java Code with Comments

import java.util.*;

public class LargestRectangleHistogram {

public static int largestRectangleArea(int[] heights) {

Stack<Integer> stack = new Stack<>(); // stores indices

 int maxArea = 0;

int n = heights.length;

for (int i = 0; i <= n; i++) {

// Use 0 height for dummy bar at the end

int currHeight = (i == n) ? 0 : heights[i];

// Pop bars taller than current

while (!stack.isEmpty() && currHeight < heights[stack.peek()]) {

int height = heights[stack.pop()];

int width = stack.isEmpty() ? i : i - stack.peek() - 1;

maxArea = Math.max(maxArea, height * width);

stack.push(i);

return maxArea;

// Driver code

public static void main(String[] args) {

int[] heights1 = {2,1,5,6,2,3};

System.out.println(largestRectangleArea(heights1)); // 10

int[] heights2 = {2,4};

 System.out.println(largestRectangleArea(heights2)); // 4

🔍 Dry Run Example

Input: [2,1,5,6,2,3]

1.​ i=0 → push 0 → stack=[0]​

2.​ i=1 → 1<2 → pop 0 → height=2, width=1 → area=2 → maxArea=2 → push1 →

stack=[1]​

3.​ i=2 → 5>1 → push2 → stack=[1,2]​

4.​ i=3 → 6>5 → push3 → stack=[1,2,3]​

5.​ i=4 → 2<6 → pop3 → height=6, width=1 → area=6 → maxArea=6​

○​ 2<5 → pop2 → height=5, width=2 → area=10 → maxArea=10 → push4 →

stack=[1,4]​

6.​ i=5 → 3>2 → push5 → stack=[1,4,5]​

7.​ i=6 → dummy 0 → pop5 → height=3, width=1 → area=3 → maxArea=10​

○​ pop4 → height=2, width=4 → area=8 → maxArea=10​

○​ pop1 → height=1, width=6 → area=6 → maxArea=10​

✅ Output: 10

📊 Complexity Analysis
Step Time Space

Traverse O(n) n = heights.length

heights
Stack O(1) amortized O(n)
operations

Total Time O(n) O(n)

Space O(n) Stack stores

indices

⚙️ Edge Cases
Case Input Output

Single bar [5] 5

Increasing heights [1,2,3,4] 6

Decreasing [4,3,2,1] 6
heights

All same height [2,2,2] 6

🧩 Key Takeaways
●​ Pattern: Monotonic stack for next smaller elements​

●​ Core Idea: Width determined by previous smaller bar index​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: Monotonic stack​

●​ Time: O(n)​

●​ Space: O(n)​

●​ Pattern: Largest rectangle / next smaller element problem​

5. Binary Search

Perfect ⚡​
Next problem in order:

Problem 28: Binary Search (Overall count: 28/150)

📝 Problem Statement
Given a sorted array of integers nums and an integer target, return the index of target
in nums.

●​ If target is not found, return -1.​

●​ You must write an algorithm with O(log n) runtime complexity.​

🔹 Examples
Example 1:

Input: nums = [-1,0,3,5,9,12], target = 9

Output: 4

Example 2:

Input: nums = [-1,0,3,5,9,12], target = 2

Output: -1

💡 Intuition
●​ Array is sorted → use binary search​

●​ Maintain low and high pointers​

●​ Check mid = (low + high)/2:​

○​ If nums[mid] == target → found​

○​ If nums[mid] < target → search right half​

○​ If nums[mid] > target → search left half​

●​ Repeat until low > high​

💻 Java Code with Comments

public class BinarySearchExample {

public static int binarySearch(int[] nums, int target) {

int low = 0, high = nums.length - 1;

while (low <= high) {

int mid = low + (high - low) / 2; // prevent overflow

 if (nums[mid] == target) {

return mid; // found target

} else if (nums[mid] < target) {

low = mid + 1; // search right half

} else {

high = mid - 1; // search left half

return -1; // target not found

// Driver code

public static void main(String[] args) {

int[] nums1 = {-1,0,3,5,9,12};

int target1 = 9;

System.out.println(binarySearch(nums1, target1)); // 4

int target2 = 2;

System.out.println(binarySearch(nums1, target2)); // -1

🔍 Dry Run Example

Input: nums = [-1,0,3,5,9,12], target = 9

1.​ low=0, high=5 → mid=2 → nums[2]=3 < 9 → search right → low=3​

2.​ low=3, high=5 → mid=4 → nums[4]=9 → found → return 4 ✅​

📊 Complexity Analysis
Operation Time Space

Binary O(log n) n = nums.length

search

Space O(1) Constant

Total Time O(log n) O(1)

⚙️ Edge Cases
Case Input Output

Empty array [] -1

Single element found [5], target=5 0

Single element not [5], target=3 -1

found

Target less than min [1,2,3], target=0 -1

 Target greater than max [1,2,3], target=4 -1

🧩 Key Takeaways
●​ Pattern: Binary search in sorted array​

●​ Core Idea: Divide and conquer​

●​ Time Complexity: O(log n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Iterative binary search​

●​ Time: O(log n)​

●​ Space: O(1)​

●​ Pattern: Classic binary search​

Perfect⚡ ​
Next problem in order:

Problem 29: Search a 2D Matrix (Overall count: 29/150)

📝 Problem Statement
Write an efficient algorithm that searches for a value target in an m x n integer matrix
matrix.

The matrix has the following properties:

 1.​ Integers in each row are sorted in ascending order from left to right.​

2.​ The first integer of each row is greater than the last integer of the previous row.​

Return true if target exists in the matrix, otherwise return false.

🔹 Examples
Example 1:

Input: matrix = [[1,3,5,7],

[10,11,16,20],

[23,30,34,50]], target = 3

Output: true

Example 2:

Input: matrix = [[1,3,5,7],

[10,11,16,20],

[23,30,34,50]], target = 13

Output: false

💡 Intuition
●​ Matrix can be treated as a sorted 1D array (row-major order)​

●​ Apply binary search on flattened indices:​

○​ midRow = mid / n​

○​ midCol = mid % n​

●​ Compare matrix[midRow][midCol] with target​

🧠 Approach (Binary Search)
1.​ Let m = matrix.length, n = matrix[0].length​

2.​ Initialize low = 0, high = m*n - 1​

3.​ While low <= high:​

○​ mid = (low + high)/2​

○​ midVal = matrix[mid/n][mid%n]​

○​ If midVal == target → return true​

○​ If midVal < target → search right (low = mid+1)​

○​ Else → search left (high = mid-1)​

4.​ Return false if not found​

💻 Java Code with Comments

public class Search2DMatrix {

public static boolean searchMatrix(int[][] matrix, int target) {

int m = matrix.length;

if (m == 0) return false;

int n = matrix[0].length;

if (n == 0) return false;

int low = 0, high = m * n - 1;

 while (low <= high) {

int mid = low + (high - low) / 2;

int midVal = matrix[mid / n][mid % n];

if (midVal == target) return true;

else if (midVal < target) low = mid + 1;

else high = mid - 1;

return false; // target not found

// Driver code

public static void main(String[] args) {

int[][] matrix1 = {

{1,3,5,7},

{10,11,16,20},

{23,30,34,50}

};

System.out.println(searchMatrix(matrix1, 3)); // true

System.out.println(searchMatrix(matrix1, 13)); // false

🔍 Dry Run Example

Input:

matrix = [[1,3,5,7],

[10,11,16,20],

[23,30,34,50]], target = 3

1.​ m=3, n=4 → total elements = 12​

2.​ low=0, high=11 → mid=5 → matrix[5/4][5%4]=matrix[1][1]=11 → 11>3 → high=4​

3.​ low=0, high=4 → mid=2 → matrix[0][2]=5 → 5>3 → high=1​

4.​ low=0, high=1 → mid=0 → matrix[0][0]=1 → 1<3 → low=1​

5.​ low=1, high=1 → mid=1 → matrix[0][1]=3 → found ✅​

Return true

📊 Complexity Analysis
Step Time Space

Binary O(log(m*n)) m = rows, n = columns

search

Space O(1) Constant

Total Time O(log(m*n)) O(1)

⚙️ Edge Cases
Case Input Output
 Empty matrix [[]] false

Single row [[1,2,3]], target=2 true

Single column [[1],[3],[5]], target=4 false

Target [[1,2],[3,4]], target=1 true

smallest

Target largest [[1,2],[3,4]], target=4 true

🧩 Key Takeaways
●​ Pattern: Binary search on 2D matrix by flattening​

●​ Core Idea: Map 1D index → 2D coordinates (row = idx/n, col = idx%n)​

●​ Time Complexity: O(log(m*n))​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Treat matrix as 1D sorted array + binary search​

●​ Time: O(log(m*n))​

●​ Space: O(1)​

●​ Pattern: Efficient search in 2D sorted matrix​

Perfect⚡ ​
Next problem in order:
Problem 30: Koko Eating Bananas (Overall count:
30/150)

📝 Problem Statement
Koko loves to eat bananas. There are piles of bananas, where piles[i] is the number of
bananas in the i-th pile.

●​ Koko can decide her eating speed k (bananas/hour).​

●​ Each hour, she chooses a pile and eats k bananas from that pile.​

○​ If the pile has fewer than k bananas, she eats all of them and stops for that
hour.​

●​ She wants to eat all bananas within h hours.​

Return the minimum integer k such that she can eat all the bananas within h hours.

🔹 Examples
Example 1:

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

Output: 4

Example 2:

Input: piles = [30,11,23,4,20], h = 5

Output: 30

💡 Intuition
 ●​ Koko’s eating speed k must be between 1 and max(piles)​

●​ For a given speed k, we can simulate total hours to eat all piles​

●​ Use binary search to find minimum k satisfying total hours ≤ h​

🧠 Approach (Binary Search on Answer)

1.​ Initialize low = 1, high = max(piles)​

2.​ While low < high:​

○​ mid = (low + high)/2 → candidate speed​

○​ Compute total hours needed at speed mid​

■​ hours += ceil(pile/mid) for each pile​

○​ If hours <= h → try lower speed → high = mid​

○​ Else → low = mid + 1​

3.​ Return low → minimum speed​

💻 Java Code with Comments

public class KokoEatingBananas {

public static int minEatingSpeed(int[] piles, int h) {

int low = 1;

int high = 0;

for (int pile : piles) high = Math.max(high, pile); // max pile

while (low < high) {

 int mid = low + (high - low) / 2;

if (canEatAll(piles, h, mid)) {

high = mid; // try smaller speed

} else {

low = mid + 1; // need higher speed

return low;

// Check if Koko can eat all piles at speed k within h hours

private static boolean canEatAll(int[] piles, int h, int k) {

int hours = 0;

for (int pile : piles) {

hours += (pile + k - 1) / k; // ceil division

return hours <= h;

// Driver code

public static void main(String[] args) {

int[] piles1 = {3,6,7,11};

int h1 = 8;

System.out.println(minEatingSpeed(piles1, h1)); // 4
 int[] piles2 = {30,11,23,4,20};

int h2 = 5;

System.out.println(minEatingSpeed(piles2, h2)); // 30

🔍 Dry Run Example

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

●​ max pile = 11 → low=1, high=11​

●​ mid=6 → total hours = ceil(3/6)+ceil(6/6)+ceil(7/6)+ceil(11/6) = 1+1+2+2=6 ≤ 8 → try

smaller → high=6​

●​ mid=3 → total hours = 1+2+3+4=10 > 8 → need faster → low=4​

●​ mid=5 → total hours = 1+2+2+3=8 ≤8 → high=5​

●​ mid=4 → total hours = 1+2+2+3=8 ≤8 → high=4 → low=4​

●​ Return 4 ✅​

📊 Complexity Analysis
Step Time Space

Binary search range [1,max(piles)] → log(max) O(n log(maxPile)) n = piles.length

Compute hours for each mid → O(n) — —

Total Time O(n log(maxPile)) O(1)

Space O(1) Constant

⚙️ Edge Cases
Case Input Output

Single pile [10], h=5 2

h = piles.length [1,2,3], h=3 max pile → 3

Large pile [1000,2000,3000], h=6 speed=1000

🧩 Key Takeaways
●​ Pattern: Binary search on answer (parametric search)​

●​ Core Idea: Minimize k such that total hours ≤ h​

●​ Time Complexity: O(n log(maxPile))​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Binary search on speed​

●​ Time: O(n log(maxPile))​

●​ Space: O(1)​

●​ Pattern: Parametric search / search on answer​

Perfect ⚡​
Next problem in order:

Problem 31: Find Minimum in Rotated Sorted Array

(Overall count: 31/150)

📝 Problem Statement
Suppose an array of unique integers nums sorted in ascending order is rotated at some
pivot unknown to you.

●​ For example, [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2].​

●​ Find the minimum element in the array.​

●​ You must write an algorithm with O(log n) runtime complexity.​

🔹 Examples
Example 1:

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

Output: 1

Example 2:

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

Output: 0

Example 3:

Input: nums = [11,13,15,17]

Output: 11
💡 Intuition
●​ Array is sorted but rotated → can use modified binary search​

●​ Key observation:​

○​ If nums[mid] > nums[high] → min is in right half​

○​ Else → min is in left half including mid​

●​ Repeat until search space reduces to one element → min element​

🧠 Approach (Modified Binary Search)

1.​ Initialize low = 0, high = nums.length - 1​

2.​ While low < high:​

○​ mid = low + (high - low)/2​

○​ If nums[mid] > nums[high] → minimum in right half → low = mid + 1​

○​ Else → minimum in left half → high = mid​

3.​ Return nums[low] → minimum element​

💻 Java Code with Comments

public class KokoEatingBananas {

public static int minEatingSpeed(int[] piles, int h) {

int low = 1;

int high = 0;
 for (int pile : piles) high = Math.max(high, pile); // max pile

while (low < high) {

int mid = low + (high - low) / 2;

if (canEatAll(piles, h, mid)) {

high = mid; // try smaller speed

} else {

low = mid + 1; // need higher speed

return low;

// Check if Koko can eat all piles at speed k within h hours

private static boolean canEatAll(int[] piles, int h, int k) {

int hours = 0;

for (int pile : piles) {

hours += (pile + k - 1) / k; // ceil division

return hours <= h;

// Driver code

public static void main(String[] args) {

int[] piles1 = {3,6,7,11};

 int h1 = 8;

System.out.println(minEatingSpeed(piles1, h1)); // 4

int[] piles2 = {30,11,23,4,20};

int h2 = 5;

System.out.println(minEatingSpeed(piles2, h2)); // 30

🔍 Dry Run Example

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

1.​ low=0, high=6 → mid=3 → nums[3]=7 > nums[6]=2 → min in right half → low=4​

2.​ low=4, high=6 → mid=5 → nums[5]=1 ≤ nums[6]=2 → min in left half → high=5​

3.​ low=4, high=5 → mid=4 → nums[4]=0 ≤ nums[5]=1 → min in left half → high=4​

4.​ low=high=4 → nums[4]=0 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(log n) → binary search

Space O(1) → constant space

⚙️ Edge Cases
Case Input Output

Array not rotated [1,2,3,4] 1

Single element [10] 10

Rotation at middle [5,6,7,1,2,3,4] 1

🧩 Key Takeaways
●​ Pattern: Binary search on rotated sorted array​

●​ Core Idea: Compare mid with high to decide search half​

●​ Time Complexity: O(log n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Modified binary search​

●​ Time: O(log n)​

●​ Space: O(1)​

●​ Pattern: Search minimum in rotated sorted array​

Perfect⚡ ​
Next problem in order:
Problem 32: Search in Rotated Sorted Array (Overall
count: 32/150)

📝 Problem Statement
Given a rotated sorted array nums of unique integers and an integer target, return the
index of target.

●​ If target is not found, return -1.​

●​ Must write an algorithm with O(log n) runtime complexity.​

🔹 Examples
Example 1:

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

Output: 4

Example 2:

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

Output: -1

Example 3:

Input: nums = [1], target = 0

Output: -1

💡 Intuition
●​ Array is rotated sorted → modified binary search​
 ●​ Key observation: At least one half of the array is sorted​

●​ Compare nums[low], nums[mid], and nums[high] to decide which half to search​

🧠 Approach (Binary Search with Rotation Check)

1.​ Initialize low = 0, high = nums.length - 1​

2.​ While low <= high:​

○​ mid = low + (high - low)/2​

○​ If nums[mid] == target → return mid​

○​ Check if left half is sorted (nums[low] <= nums[mid]):​

■​ If target in left half → search left → high = mid-1​

■​ Else → search right → low = mid+1​

○​ Else (right half is sorted):​

■​ If target in right half → low = mid+1​

■​ Else → high = mid-1​

3.​ Return -1 if not found​

💻 Java Code with Comments

public class SearchInRotatedSortedArray {

/**

* Searches for target in rotated sorted array.

*
* @param nums rotated sorted array of unique integers

* @param target integer to find

* @return index of target, -1 if not found

*/

public static int search(int[] nums, int target) {

int low = 0, high = nums.length - 1;

while (low <= high) {

int mid = low + (high - low) / 2;

// Check if mid element is the target

if (nums[mid] == target) {

return mid;

// Determine which half is sorted

if (nums[low] <= nums[mid]) {

// Left half is sorted

if (nums[low] <= target && target < nums[mid]) {

// Target in left half

high = mid - 1;

} else {

// Target in right half

low = mid + 1;

} else {
 // Right half is sorted

if (nums[mid] < target && target <= nums[high]) {

// Target in right half

low = mid + 1;

} else {

// Target in left half

high = mid - 1;

// Target not found

return -1;

// Driver code

public static void main(String[] args) {

int[] nums1 = {4,5,6,7,0,1,2};

int target1 = 0;

System.out.println(search(nums1, target1)); // Output: 4

int target2 = 3;

System.out.println(search(nums1, target2)); // Output: -1

int[] nums2 = {1};

int target3 = 0;
 System.out.println(search(nums2, target3)); // Output: -1

🔍 Dry Run Example

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

1.​ low=0, high=6 → mid=3 → nums[3]=7 ≠ 0​

2.​ Left half sorted? nums[0]=4 ≤ nums[3]=7 → yes​

○​ Is target in left? 4 ≤ 0 < 7 → no → search right → low=4​

3.​ low=4, high=6 → mid=5 → nums[5]=1 ≠ 0​

4.​ Left half sorted? nums[4]=0 ≤ nums[5]=1 → yes​

○​ Is target in left? 0 ≤ 0 < 1 → yes → high=4​

5.​ low=4, high=4 → mid=4 → nums[4]=0 → found ✅​

Return 4

📊 Complexity Analysis
Aspec Complexity
t

Time O(log n) → binary search

Space O(1) → constant space

⚙️ Edge Cases
 Case Input Output

Single element found [1], target=1 0

Single element not [1], target=0 -1

found

No rotation [1,2,3,4], target=3 2

Full rotation [4,5,1,2,3], target=1 2

🧩 Key Takeaways
●​ Pattern: Binary search with rotated array check​

●​ Core Idea: At least one half is sorted → narrow search​

●​ Time Complexity: O(log n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Modified binary search using sorted half property​

●​ Time: O(log n)​

●​ Space: O(1)​

●​ Pattern: Search in rotated sorted array efficiently​

Perfect ⚡​
Next problem in order:
Problem 33: Time Based Key-Value Store (Overall
count: 33/150)

📝 Problem Statement
Design a time-based key-value store that supports two operations:

1.​ set(key, value, timestamp)​

○​ Stores the key and value, along with the given timestamp.​

2.​ get(key, timestamp)​

○​ Returns a value such that set(key, value, t) was called previously

with t <= timestamp.​

○​ If there are multiple such values, return the one with the largest timestamp ≤
timestamp.​

○​ If no such value exists, return "".​

🔹 Examples
Example 1:

Input:

set("foo", "bar", 1)

get("foo", 1) → "bar"

get("foo", 3) → "bar"

set("foo", "bar2", 4)

get("foo", 4) → "bar2"

get("foo", 5) → "bar2"
💡 Intuition
●​ For each key, maintain a sorted list of (timestamp, value)​

●​ set → append to list​

●​ get → binary search for largest timestamp ≤ target​

🧠 Approach
1.​ Use a HashMap<String, List<Pair<Integer,String>>>​

○​ Key → list of (timestamp, value) pairs, sorted by timestamp​

2.​ set(key, value, timestamp) → append (timestamp, value) to the list​

3.​ get(key, timestamp) → binary search in the list to find floor timestamp​

○​ Return corresponding value or "" if none exists​

💻 Java Code with Comments

import java.util.*;

class TimeMap {

// Map each key to a list of (timestamp, value) pairs

private Map<String, List<Pair>> map;

// Pair class to store timestamp and value

private static class Pair {

 int time;

String value;

Pair(int time, String value) {

this.time = time;

this.value = value;

/** Initialize the data structure */

public TimeMap() {

map = new HashMap<>();

/** Stores the key-value pair along with timestamp */

public void set(String key, String value, int timestamp) {

map.putIfAbsent(key, new ArrayList<>());

map.get(key).add(new Pair(timestamp, value));

/** Returns the value associated with key at given timestamp */

public String get(String key, int timestamp) {

if (!map.containsKey(key)) return "";

List<Pair> list = map.get(key);

int low = 0, high = list.size() - 1;

String result = "";

 // Binary search for largest timestamp <= target

while (low <= high) {

int mid = low + (high - low) / 2;

if (list.get(mid).time <= timestamp) {

result = list.get(mid).value; // candidate value

low = mid + 1; // search right for larger timestamp ≤ target

} else {

high = mid - 1; // search left

return result;

// Driver code

public static void main(String[] args) {

TimeMap tm = new TimeMap();

tm.set("foo", "bar", 1);

System.out.println(tm.get("foo", 1)); // "bar"

System.out.println(tm.get("foo", 3)); // "bar"

tm.set("foo", "bar2", 4);

System.out.println(tm.get("foo", 4)); // "bar2"

System.out.println(tm.get("foo", 5)); // "bar2"

}
🔍 Dry Run Example
●​ set("foo", "bar", 1) → map: {"foo": [(1,"bar")]}​

●​ get("foo",3) → binary search → largest timestamp ≤ 3 → 1 → value="bar"​

●​ set("foo", "bar2", 4) → map: {"foo": [(1,"bar"),(4,"bar2")]}​

●​ get("foo",4) → timestamp=4 → value="bar2"​

●​ get("foo",5) → largest timestamp ≤5 → 4 → value="bar2"​

📊 Complexity Analysis
Operation Time Space

set O(1) amortized O(n) total for all pairs

get O(log m) → m = #pairs for key O(1) auxiliary

Space O(n) for storing all key-value-time pairs

⚙️ Edge Cases
Case Input Output

Key not set get("bar",1) ""

Timestamp before first set get("foo",0) ""

 Multiple values get("foo",4) latest ≤4

🧩 Key Takeaways
●​ Pattern: Binary search over timestamps​

●​ Core Idea: Store sorted timestamp-value pairs → floor query using binary search​

●​ Time Complexity: set O(1), get O(log m)​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: HashMap + binary search over timestamp list​

●​ Time: Efficient get using binary search​

●​ Space: Store all values​

●​ Pattern: Time-based key-value store​

Perfect⚡ ​
Next problem in order:

Problem 34: Median of Two Sorted Arrays (Overall

count: 34/150)

📝 Problem Statement
Given two sorted arrays nums1 and nums2 of sizes m and n, return the median of the two
sorted arrays.
 ●​ The overall run time complexity must be O(log (m+n)).​

🔹 Examples
Example 1:

Input: nums1 = [1,3], nums2 = [2]

Output: 2.0

Example 2:

Input: nums1 = [1,2], nums2 = [3,4]

Output: 2.5

💡 Intuition
●​ Merging arrays → O(m+n) → too slow​

●​ Use binary search to partition arrays:​

Partition nums1 and nums2 such that:​

​
left_part: all elements ≤ median

right_part: all elements ≥ median

○​
○​ Ensure maxLeft1 ≤ minRight2 and maxLeft2 ≤ minRight1​

●​ Median depends on even/odd total length.​

🧠 Approach (Binary Search on Smaller Array)

 1.​ Ensure nums1 is smaller array (binary search on smaller array).​

Let i = partition index in nums1, j = partition index in nums2:​

​
j = (m + n + 1)/2 - i

2.​
3.​ Compute maxLeft1, minRight1, maxLeft2, minRight2.​

4.​ If maxLeft1 ≤ minRight2 and maxLeft2 ≤ minRight1 → correct partition​

○​ If total length even → median = (max(maxLeft1,maxLeft2) +

min(minRight1,minRight2))/2​

○​ If odd → median = max(maxLeft1,maxLeft2)​

5.​ Else adjust partition i using binary search.​

💻 Java Code with Comments

public class MedianOfTwoSortedArrays {

/**

* Finds median of two sorted arrays in O(log(min(m,n))) time.

* @param nums1 first sorted array

* @param nums2 second sorted array

* @return median value

*/

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {

// Ensure nums1 is smaller

if (nums1.length > nums2.length) {

 return findMedianSortedArrays(nums2, nums1);

int m = nums1.length;

int n = nums2.length;

int low = 0, high = m;

while (low <= high) {

int i = low + (high - low)/2; // partition nums1

int j = (m + n + 1)/2 - i; // partition nums2

int maxLeft1 = (i == 0) ? Integer.MIN_VALUE : nums1[i-1];

int minRight1 = (i == m) ? Integer.MAX_VALUE : nums1[i];

int maxLeft2 = (j == 0) ? Integer.MIN_VALUE : nums2[j-1];

int minRight2 = (j == n) ? Integer.MAX_VALUE : nums2[j];

// Check if correct partition

if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {

// Odd total length

if ((m + n) % 2 == 1) {

return Math.max(maxLeft1, maxLeft2);

} else {

// Even total length

return (Math.max(maxLeft1, maxLeft2) +

Math.min(minRight1, minRight2)) / 2.0;
 }

} else if (maxLeft1 > minRight2) {

// Move partition i left

high = i - 1;

} else {

// Move partition i right

low = i + 1;

throw new IllegalArgumentException("Input arrays are not sorted

properly");

// Driver code

public static void main(String[] args) {

int[] nums1 = {1,3};

int[] nums2 = {2};

System.out.println(findMedianSortedArrays(nums1, nums2)); // 2.0

int[] nums3 = {1,2};

int[] nums4 = {3,4};

System.out.println(findMedianSortedArrays(nums3, nums4)); // 2.5

}
🔍 Dry Run Example
Input: nums1=[1,3], nums2=[2]

1.​ nums1 smaller → binary search on nums1​

2.​ low=0, high=2 → i=1, j=(3+1)/2-1=1​

3.​ maxLeft1=1, minRight1=3, maxLeft2=2, minRight2=∞​

4.​ Check partition: maxLeft1 ≤ minRight2 (1 ≤ ∞) ✅, maxLeft2 ≤ minRight1 (2 ≤3) ✅ →

correct​

5.​ Total length odd → median = max(1,2)=2 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(log(min(m,n))) → binary search on smaller array

Space O(1) → constant extra space

⚙️ Edge Cases
Case Input Output

One empty array nums1=[], nums2=[1] 1.0

Both arrays same nums1=[1,2], nums2=[3,4] 2.5

size
 All elements equal nums1=[2,2], nums2=[2,2] 2.0

🧩 Key Takeaways
●​ Pattern: Binary search on smaller array for partition​

●​ Core Idea: Partition both arrays to split left/right halves​

●​ Time Complexity: O(log(min(m,n)))​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Binary search on partition​

●​ Time: O(log(min(m,n)))​

●​ Space: O(1)​

●​ Pattern: Median of two sorted arrays using partition​

6. LinkedList

Perfect⚡ ​
Next problem in order:

Problem 35: Reverse Linked List (Overall count: 35/150)

📝 Problem Statement
Given the head of a singly linked list, reverse the list and return its new head.

🔹 Examples
Example 1:
Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

Example 2:
Input: head = [1,2]
Output: [2,1]

Example 3:
Input: head = []
Output: []

💡 Intuition
●​ Iterate through the list and reverse the pointers​

●​ Keep track of previous node to point current node’s next to it​

●​ Use 3 pointers: prev, curr, nextTemp​

🧠 Approach (Iterative)
1.​ Initialize: prev = null, curr = head​

2.​ Loop while curr != null:​

○​ Store curr.next in nextTemp​

○​ Reverse pointer: curr.next = prev​

○​ Move prev = curr, curr = nextTemp​

 3.​ Return prev → new head of reversed list​

💻 Java Code with Comments

// Definition for singly-linked list.
class ListNode {
int val;
ListNode next;
ListNode(int val) { this.val = val; }
}

public class ReverseLinkedList {

/**
* Reverses a singly linked list iteratively.
*
* @param head head of the linked list
* @return new head of reversed linked list
*/
public static ListNode reverseList(ListNode head) {
ListNode prev = null; // Previous node, initially null
ListNode curr = head; // Current node

while (curr != null) {

ListNode nextTemp = curr.next; // Store next node
curr.next = prev; // Reverse current node's pointer
prev = curr; // Move prev forward
curr = nextTemp; // Move curr forward
}

return prev; // New head

}

// Helper function to print linked list

public static void printList(ListNode head) {
ListNode temp = head;
while (temp != null) {
System.out.print(temp.val + " ");
temp = temp.next;
}
System.out.println();
}
 // Driver code
public static void main(String[] args) {
// Creating linked list 1->2->3->4->5
ListNode head = new ListNode(1);
head.next = new ListNode(2);
head.next.next = new ListNode(3);
head.next.next.next = new ListNode(4);
head.next.next.next.next = new ListNode(5);

System.out.println("Original List:");
printList(head);

ListNode reversedHead = reverseList(head);

System.out.println("Reversed List:");
printList(reversedHead);
}
}

🔍 Dry Run Example

Input: head = [1,2,3]

●​ Initialize: prev=null, curr=1​

●​ Iteration 1:​

○​ nextTemp = 2​

○​ 1.next = null​

○​ prev=1, curr=2​

●​ Iteration 2:​

○​ nextTemp = 3​

○​ 2.next = 1​

○​ prev=2, curr=3​

●​ Iteration 3:​
 ○​ nextTemp = null​

○​ 3.next = 2​

○​ prev=3, curr=null​

●​ Return prev = 3 → Reversed list: 3->2->1 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n) → iterate through all nodes

Space O(1) → constant extra space

⚙️ Edge Cases
Case Input Output

Empty list head=null null

Single head=[1] [1]

node

Two nodes head=[1,2] [2,1]

🧩 Key Takeaways
●​ Pattern: Iterative pointer reversal in linked list​

●​ Core Idea: Keep track of previous node and reverse next pointers​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
 ●​ Approach: Iterative reversal using 3 pointers​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Linked list pointer manipulation​

Perfect ⚡
​
Next problem in order:

Problem 36: Merge Two Sorted Lists (Overall count:

36/150)

📝 Problem Statement
Given the heads of two sorted linked lists list1 and list2, merge them into a single
sorted list.

●​ Return the merged linked list.​

●​ The list should be made by splicing together the nodes of the first two lists.​

🔹 Examples
Example 1:
Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

Example 2:
Input: list1 = [], list2 = []
Output: []

Example 3:
Input: list1 = [], list2 = [0]
Output: [0]
💡 Intuition
●​ Since both lists are sorted, we can merge them like in merge sort.​

●​ Compare the heads of both lists, pick the smaller, and move forward.​

●​ Use a dummy node to simplify merging.​

🧠 Approach (Iterative)
1.​ Create a dummy node → tail = dummy​

2.​ While both list1 and list2 are not null:​

○​ Compare list1.val and list2.val​

○​ Append the smaller node to tail.next​

○​ Move that list forward​

○​ Move tail forward​

3.​ Attach the remaining nodes (if any) from list1 or list2​

4.​ Return dummy.next → merged list head​

💻 Java Code with Comments

// Definition for singly-linked list.
class ListNode {
int val;
ListNode next;
ListNode(int val) { this.val = val; }
}

public class MergeTwoSortedLists {

/**
* Merges two sorted linked lists iteratively.
*
* @param list1 head of first sorted list
* @param list2 head of second sorted list
* @return head of merged sorted list
*/
public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {
// Dummy node to simplify merging
ListNode dummy = new ListNode(-1);
ListNode tail = dummy;

// Merge nodes while both lists are non-empty

while (list1 != null && list2 != null) {
if (list1.val <= list2.val) {
tail.next = list1; // attach list1 node
list1 = list1.next; // move list1 forward
} else {
tail.next = list2; // attach list2 node
list2 = list2.next; // move list2 forward
}
tail = tail.next; // move tail forward
}

// Attach remaining nodes (if any)

if (list1 != null) tail.next = list1;
if (list2 != null) tail.next = list2;

// Return merged list head

return dummy.next;
}

// Helper function to print linked list

public static void printList(ListNode head) {
ListNode temp = head;
while (temp != null) {
System.out.print(temp.val + " ");
temp = temp.next;
}
System.out.println();
}

// Driver code
public static void main(String[] args) {
// Creating first list 1->2->4
ListNode list1 = new ListNode(1);
 list1.next = new ListNode(2);
list1.next.next = new ListNode(4);

// Creating second list 1->3->4

ListNode list2 = new ListNode(1);
list2.next = new ListNode(3);
list2.next.next = new ListNode(4);

ListNode mergedHead = mergeTwoLists(list1, list2);

System.out.println("Merged List:");
printList(mergedHead); // Output: 1 1 2 3 4 4
}
}

🔍 Dry Run Example

Input: list1 = [1,2,4], list2 = [1,3,4]

●​ Initialize dummy=-1, tail=dummy​

●​ Compare 1 and 1 → attach list1 → tail=1 → move list1 to 2​

●​ Compare 2 and 1 → attach list2 → tail=1 → move list2 to 3​

●​ Compare 2 and 3 → attach list1 → tail=2 → move list1 to 4​

●​ Compare 4 and 3 → attach list2 → tail=3 → move list2 to 4​

●​ Compare 4 and 4 → attach list1 → tail=4 → move list1=null​

●​ Attach remaining list2 → 4​

●​ Merged list: 1->1->2->3->4->4 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n + m) → n = list1 length, m = list2 length

Space O(1) → iterative merge, only dummy node used

⚙️ Edge Cases
Case Input Output

One empty list list1=[], list2=[0] [0]

Both empty list1=[], list2=[] []

Single node list1=[1], list2=[2] [1,2]

each

🧩 Key Takeaways
●​ Pattern: Merge two sorted lists (like merge sort)​

●​ Core Idea: Compare heads iteratively, attach smaller node​

●​ Time Complexity: O(n + m)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Iterative merge with dummy node​

●​ Time: O(n + m)​

●​ Space: O(1)​

●​ Pattern: Linked list merge​

Perfect⚡ ​
Next problem in order:

Problem 37: Linked List Cycle (Overall count: 37/150)

📝 Problem Statement
Given the head of a linked list, determine if the list contains a cycle.

●​ A cycle exists if some node in the list points back to a previous node.​

●​ Return true if there is a cycle, otherwise false..​

🔹 Examples
Example 1:

Input: head = [3,2,0,-4], pos = 1

Output: true

Explanation: tail connects to node index 1 (value 2)

Example 2:

Input: head = [1,2], pos = 0

Output: true

Example 3:

Input: head = [1], pos = -1

Output: false

💡 Intuition
●​ Use two pointers (Floyd’s Tortoise and Hare)​

●​ Slow pointer moves 1 step, fast pointer moves 2 steps​

●​ If cycle exists, fast and slow will eventually meet​

●​ If fast reaches null, no cycle exists​

🧠 Approach (Floyd’s Cycle Detection)
1.​ Initialize slow = head, fast = head​

2.​ Loop while fast != null && fast.next != null:​

○​ slow = slow.next​

○​ fast = fast.next.next​

○​ If slow == fast → cycle detected → return true​

3.​ If loop ends → no cycle → return false​

💻 Java Code with Comments

// Definition for singly-linked list.

class ListNode {

int val;

ListNode next;

ListNode(int val) { this.val = val; }

public class LinkedListCycle {

/**

* Detects if a linked list has a cycle using two pointers.

* @param head head of linked list

* @return true if cycle exists, false otherwise

*/

public static boolean hasCycle(ListNode head) {

if (head == null || head.next == null) return false;

ListNode slow = head; // moves 1 step at a time

ListNode fast = head; // moves 2 steps at a time

while (fast != null && fast.next != null) {

slow = slow.next;

fast = fast.next.next;

// Cycle detected if slow meets fast

if (slow == fast) return true;

// No cycle detected

return false;

// Driver code

public static void main(String[] args) {

// Creating linked list 3->2->0->-4 with cycle at position 1

ListNode head = new ListNode(3);

ListNode node2 = new ListNode(2);

ListNode node0 = new ListNode(0);

ListNode nodeNeg4 = new ListNode(-4);

 head.next = node2;

node2.next = node0;

node0.next = nodeNeg4;

nodeNeg4.next = node2; // cycle

System.out.println(hasCycle(head)); // Output: true

// Linked list without cycle

ListNode head2 = new ListNode(1);

head2.next = new ListNode(2);

System.out.println(hasCycle(head2)); // Output: false

🔍 Dry Run Example

Input: head = [3,2,0,-4], pos=1

●​ Initialize slow=3, fast=3​

●​ Step 1: slow=2, fast=0​

●​ Step 2: slow=0, fast=2​

●​ Step 3: slow=-4, fast=-4 → slow == fast ✅ → cycle detected​

📊 Complexity Analysis
 Aspec Complexity
t

Time O(n) → each node visited at most twice

Space O(1) → two pointers only

⚙️ Edge Cases
Case Input Output

Empty list head=null false

Single node no cycle head=[1] false

Single node with cycle head=[1], pos=0 true

🧩 Key Takeaways
●​ Pattern: Floyd’s Tortoise and Hare​

●​ Core Idea: Two pointers at different speeds → meet if cycle exists​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
 ●​ Approach: Two-pointer cycle detection​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Linked list cycle detection​

Perfect ⚡
​
Next problem in order:

Problem 38: Reorder List (Overall count: 38/150)

📝 Problem Statement
Given the head of a singly linked list, reorder it as follows:

L0 → L1 → … → Ln-1 → Ln

to

L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

●​ You may not modify the values in the list's nodes.​

●​ You must reorder the nodes in-place.​

🔹 Examples
Example 1:

Input: head = [1,2,3,4]

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

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

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

💡 Intuition
●​ Split list into two halves​

●​ Reverse the second half​

●​ Merge two halves alternatingly​

🧠 Approach (3 Steps)
1.​ Find middle using slow and fast pointers​

2.​ Reverse second half​

3.​ Merge two halves:​

first: 1 -> 2 -> 3

second (reversed): 5 -> 4

Merge: 1->5->2->4->3

💻 Java Code with Comments

// Definition for singly-linked list.

class ListNode {

int val;
 ListNode next;

ListNode(int val) { this.val = val; }

public class ReorderList {

/**

* Reorders linked list in-place as per problem statement.

* @param head head of linked list

*/

public static void reorderList(ListNode head) {

if (head == null || head.next == null) return;

// Step 1: Find middle

ListNode slow = head, fast = head;

while (fast.next != null && fast.next.next != null) {

slow = slow.next;

fast = fast.next.next;

// Step 2: Reverse second half

ListNode second = reverseList(slow.next);

slow.next = null; // Split the list into two halves

// Step 3: Merge two halves

 ListNode first = head;

while (second != null) {

ListNode temp1 = first.next;

ListNode temp2 = second.next;

first.next = second;

second.next = temp1;

first = temp1;

second = temp2;

// Helper function to reverse a linked list

private static ListNode reverseList(ListNode head) {

ListNode prev = null, curr = head;

while (curr != null) {

ListNode nextTemp = curr.next;

curr.next = prev;

prev = curr;

curr = nextTemp;

return prev;

// Helper function to print linked list

public static void printList(ListNode head) {

ListNode temp = head;

while (temp != null) {

System.out.print(temp.val + " ");

temp = temp.next;

System.out.println();

// Driver code

public static void main(String[] args) {

// Creating list 1->2->3->4->5

ListNode head = new ListNode(1);

head.next = new ListNode(2);

head.next.next = new ListNode(3);

head.next.next.next = new ListNode(4);

head.next.next.next.next = new ListNode(5);

System.out.println("Original List:");

printList(head);

reorderList(head);

System.out.println("Reordered List:");

printList(head); // Output: 1 5 2 4 3

}
}

🔍 Dry Run Example

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

1.​ Find middle → slow at 3​

2.​ Reverse second half → 5->4​

3.​ Merge:​

○​ 1→5→2→4→3 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n) → traverse list multiple times

Space O(1) → in-place reordering

⚙️ Edge Cases
Case Input Output

Empty list head=null null

Single head=[1] [1]

node
 Two nodes head=[1,2] [1,2]

🧩 Key Takeaways
●​ Pattern: Split → Reverse → Merge​

●​ Core Idea: Use slow/fast pointers + in-place merge​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Find middle → reverse second half → merge halves​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Reorder linked list in-place​

Perfect⚡ ​
Next problem in order:

Problem 39: Remove Nth Node From End of List

(Overall count: 39/150)

📝 Problem Statement
Given the head of a linked list, remove the n-th node from the end of the list and return its
head.
 ●​ Do it in one pass if possible.​

🔹 Examples
Example 1:

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

Output: [1,2,3,5]

Example 2:

Input: head = [1], n = 1

Output: []

Example 3:

Input: head = [1,2], n = 1

Output: [1]

💡 Intuition
●​ Use two pointers (first and second) separated by n nodes​

●​ Move first n steps ahead​

●​ Move both pointers until first reaches the end → second points to node before
target​

●​ Remove target by updating second.next​

🧠 Approach (Two Pointers / One Pass)

 1.​ Create a dummy node before head → simplifies edge cases​

2.​ Initialize first = dummy, second = dummy​

3.​ Move first n + 1 steps ahead → maintain gap of n​

4.​ Move both first and second until first reaches null​

5.​ Remove target → second.next = second.next.next​

6.​ Return dummy.next​

💻 Java Code with Comments

// Definition for singly-linked list.

class ListNode {

int val;

ListNode next;

ListNode(int val) { this.val = val; }

public class RemoveNthNodeFromEnd {

/**

* Removes the n-th node from the end of linked list.

* @param head head of the list

* @param n position from the end

* @return head of modified list

*/
public static ListNode removeNthFromEnd(ListNode head, int n) {

// Dummy node simplifies removal of head

ListNode dummy = new ListNode(0);

dummy.next = head;

ListNode first = dummy;

ListNode second = dummy;

// Move first n+1 steps ahead

for (int i = 0; i <= n; i++) {

first = first.next;

// Move both pointers until first reaches end

while (first != null) {

first = first.next;

second = second.next;

// Remove nth node from end

second.next = second.next.next;

return dummy.next;

// Helper function to print linked list

public static void printList(ListNode head) {

 ListNode temp = head;

while (temp != null) {

System.out.print(temp.val + " ");

temp = temp.next;

System.out.println();

// Driver code

public static void main(String[] args) {

// Creating list 1->2->3->4->5

ListNode head = new ListNode(1);

head.next = new ListNode(2);

head.next.next = new ListNode(3);

head.next.next.next = new ListNode(4);

head.next.next.next.next = new ListNode(5);

System.out.println("Original List:");

printList(head);

head = removeNthFromEnd(head, 2); // Remove 2nd node from end

System.out.println("Modified List:");

printList(head); // Output: 1 2 3 5

}
🔍 Dry Run Example
Input: head = [1,2,3,4,5], n = 2

●​ Dummy → 0->1->2->3->4->5​

●​ Move first 3 steps ahead → points at 3​

●​ Move both pointers until first null → second points at 3​

●​ Remove second.next → node 4 removed​

●​ Result: 1->2->3->5 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n) → traverse list once

Space O(1) → constant extra

space

⚙️ Edge Cases
Case Input Output

Remove head=[1,2], n=2 [2]

head
 Single node head=[1], n=1 []

Last node head=[1,2,3], n=1 [1,2]

🧩 Key Takeaways
●​ Pattern: Two-pointer / fast & slow​

●​ Core Idea: Maintain gap of n+1 → pointer just before node to remove​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Two-pointer one-pass removal​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Linked list removal using dummy and two pointers​

Perfect⚡ ​
Next problem in order:

Problem 40: Copy List With Random Pointer (Overall

count: 40/150)

📝 Problem Statement
A linked list is given such that each node contains an additional random pointer which
could point to any node in the list or null.

●​ Return a deep copy of the list.​

Node {

int val;

Node next;

Node random;

🔹 Examples
Example 1:

Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]

Output: A deep copy of the list

Example 2:

Input: head = []

Output: []

💡 Intuition
●​ Need deep copy → new nodes with same values​

●​ Each random pointer must point to corresponding new node​

●​ Can use HashMap to map old nodes → new nodes​

🧠 Approach (HashMap)
1.​ Traverse original list → create new nodes → store in Map<OldNode, NewNode>​

2.​ Traverse again → set next and random pointers using map​

3.​ Return map.get(head) as new head​

●​ Alternative approach: Interweave nodes to reduce space to O(1)​

💻 Java Code with Comments (HashMap Approach)

import java.util.*;

// Definition for a Node.

class Node {

int val;

Node next;

Node random;

Node(int val) { this.val = val; this.next = null; this.random = null; }

public class CopyListWithRandomPointer {

/**

* Makes a deep copy of a linked list with random pointers.

* @param head head of original list

* @return head of copied list

*/

public static Node copyRandomList(Node head) {

if (head == null) return null;

Map<Node, Node> map = new HashMap<>();

// Step 1: Copy nodes

Node curr = head;

while (curr != null) {

map.put(curr, new Node(curr.val));

curr = curr.next;

// Step 2: Copy next and random pointers

curr = head;

while (curr != null) {

map.get(curr).next = map.get(curr.next); // next pointer

map.get(curr).random = map.get(curr.random); // random pointer

curr = curr.next;

// Return head of copied list

return map.get(head);

}
 // Helper function to print list (val, randomVal)

public static void printList(Node head) {

Node temp = head;

while (temp != null) {

int randomVal = temp.random != null ? temp.random.val : -1;

System.out.print("(" + temp.val + "," + randomVal + ") ");

temp = temp.next;

System.out.println();

// Driver code

public static void main(String[] args) {

// Create original list

Node n1 = new Node(7);

Node n2 = new Node(13);

Node n3 = new Node(11);

Node n4 = new Node(10);

Node n5 = new Node(1);

n1.next = n2; n2.next = n3; n3.next = n4; n4.next = n5;

n1.random = null; n2.random = n1; n3.random = n5; n4.random = n3;

n5.random = n1;

System.out.println("Original List:");

printList(n1);
 Node copiedHead = copyRandomList(n1);

System.out.println("Copied List:");

printList(copiedHead);

🔍 Dry Run Example

●​ Original list: 7->13->11->10->1 with random pointers​

●​ Step 1: Create new nodes → map old → new​

●​ Step 2: Set next and random using map​

●​ Result → deep copy, new nodes, same structure​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n) → traverse list twice

Space O(n) → HashMap stores old → new

nodes

⚙️ Edge Cases
Case Input Output
 Empty list head=null null

Single node head=[1,null] [1,null]

Random points to itself head=[1,1] deep copy

maintained

🧩 Key Takeaways
●​ Pattern: HashMap for mapping original → copy nodes​

●​ Core Idea: Copy nodes first, then assign next and random​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: HashMap deep copy​

●​ Time: O(n)​

●​ Space: O(n)​

●​ Pattern: Linked list with random pointers deep copy​

Perfect⚡ ​
Next problem in order:

Problem 41: Add Two Numbers (Overall count: 41/150)

📝 Problem Statement
You are given two non-empty linked lists representing two non-negative integers.

●​ The digits are stored in reverse order.​

●​ Each node contains a single digit.​

●​ Add the two numbers and return the sum as a linked list.​

Example: (2 -> 4 -> 3) + (5 -> 6 -> 4) = 7 -> 0 -> 8

Explanation: 342 + 465 = 807

🔹 Examples
Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]

Output: [7,0,8]

Example 2:

Input: l1 = [0], l2 = [0]

Output: [0]

Example 3:

Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]

Output: [8,9,9,9,0,0,0,1]

💡 Intuition
●​ Add digit by digit like elementary school addition​
 ●​ Keep carry for sums ≥ 10​

●​ Use dummy node to simplify list creation​

🧠 Approach (Iterative)
1.​ Initialize dummy node and current pointer​

2.​ Initialize carry = 0​

3.​ While l1 != null || l2 != null || carry != 0:​

○​ Sum = carry + l1.val + l2.val (use 0 if null)​

○​ carry = sum / 10​

○​ Create new node with sum % 10​

○​ Move pointers l1, l2, current​

4.​ Return dummy.next → head of result​

💻 Java Code with Comments

// Definition for singly-linked list.

class ListNode {

int val;

ListNode next;

ListNode(int val) { this.val = val; }

public class AddTwoNumbers {

/**

* Adds two numbers represented as linked lists.

* @param l1 first linked list

* @param l2 second linked list

* @return head of the sum linked list

*/

public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {

ListNode dummy = new ListNode(0); // Dummy node

ListNode current = dummy;

int carry = 0;

while (l1 != null || l2 != null || carry != 0) {

int x = (l1 != null) ? l1.val : 0;

int y = (l2 != null) ? l2.val : 0;

int sum = x + y + carry;

carry = sum / 10;

current.next = new ListNode(sum % 10); // New node with digit

current = current.next;

if (l1 != null) l1 = l1.next;

if (l2 != null) l2 = l2.next;

}
 return dummy.next;

// Helper function to print linked list

public static void printList(ListNode head) {

ListNode temp = head;

while (temp != null) {

System.out.print(temp.val + " ");

temp = temp.next;

System.out.println();

// Driver code

public static void main(String[] args) {

// List 1: 2->4->3

ListNode l1 = new ListNode(2);

l1.next = new ListNode(4);

l1.next.next = new ListNode(3);

// List 2: 5->6->4

ListNode l2 = new ListNode(5);

l2.next = new ListNode(6);

l2.next.next = new ListNode(4);

 ListNode result = addTwoNumbers(l1, l2);

System.out.println("Sum List:");

printList(result); // Output: 7 0 8

🔍 Dry Run Example

Input: l1=[2,4,3], l2=[5,6,4]

●​ Step 1: 2+5=7, carry=0 → node 7​

●​ Step 2: 4+6=10, carry=1 → node 0​

●​ Step 3: 3+4+carry=8 → node 8​

●​ Result: 7->0->8 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(max(m,n)) → traverse both lists

Space O(max(m,n)) → for result list

⚙️ Edge Cases
 Case Input Output

One list empty l1=[], l2=[1,2] [1,2]

Carry over extra l1=[9], l2=[1] [0,1]

node

Both single node l1=[5], l2=[5] [0,1]

🧩 Key Takeaways
●​ Pattern: Linked list digit-wise addition​

●​ Core Idea: Keep carry and use dummy node​

●​ Time Complexity: O(max(m,n))​

●​ Space Complexity: O(max(m,n))​

✅ Final Summary
●​ Approach: Iterative addition with carry​

●​ Time: O(max(m,n))​

●​ Space: O(max(m,n))​

●​ Pattern: Elementary addition with linked lists​

Perfect⚡ ​
Next problem in order:
Problem 42: Find the Duplicate Number (Overall count:
42/150)

📝 Problem Statement
Given an array nums containing n + 1 integers where each integer is in the range [1, n]
inclusive:

●​ There is only one repeated number, but it could be repeated more than once.​

●​ Return the duplicate number without modifying the array and using O(1) extra
space.​

🔹 Examples
Example 1:

Input: nums = [1,3,4,2,2]

Output: 2

Example 2:

Input: nums = [3,1,3,4,2]

Output: 3

💡 Intuition
●​ Array values are in [1, n] → can treat as linked list using indices​

●​ Duplicate → cycle exists (like linked list cycle detection)​

●​ Use Floyd’s Tortoise and Hare to find the cycle start → duplicate number​
🧠 Approach (Floyd’s Cycle Detection)
1.​ Treat array as linked list:​

○​ index = value​

○​ Start from slow = nums[0], fast = nums[0]​

2.​ Move pointers:​

○​ slow = nums[slow]​

○​ fast = nums[nums[fast]]​

3.​ Detect cycle: slow == fast → break​

4.​ Find cycle start (duplicate):​

○​ Reset slow = nums[0]​

○​ Move slow and fast one step at a time until they meet​

○​ Meeting point → duplicate number​

💻 Java Code with Comments

public class FindDuplicateNumber {

/**
* Finds the duplicate number using Floyd's Tortoise and Hare algorithm.
*
* @param nums input array with n+1 integers
* @return duplicate number
*/
public static int findDuplicate(int[] nums) {
int slow = nums[0];
int fast = nums[0];

// Step 1: Detect cycle

do {
slow = nums[slow];
fast = nums[nums[fast]];
} while (slow != fast);
 // Step 2: Find entry point of cycle (duplicate)
slow = nums[0];
while (slow != fast) {
slow = nums[slow];
fast = nums[fast];
}

return slow; // Duplicate number

}

// Driver code
public static void main(String[] args) {
int[] nums1 = {1,3,4,2,2};
System.out.println("Duplicate: " + findDuplicate(nums1)); // Output:
2

int[] nums2 = {3,1,3,4,2};

System.out.println("Duplicate: " + findDuplicate(nums2)); // Output:
3
}
}

🔍 Dry Run Example

Input: [1,3,4,2,2]

●​ Step 1: slow=1, fast=1 → move: slow=3, fast=4 → slow=2, fast=2 → slow==fast ✅​

●​ Step 2: reset slow=1 → move: slow=3, fast=3 → meet at 2 → duplicate=2 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n) → traverse array using two pointers

Space O(1) → constant extra space

⚙️ Edge Cases
Case Input Output

Duplicate at start [2,2,3,4,5] 2

Duplicate at end [1,3,4,5,3] 3

Multiple duplicates [1,1,2,3,4] 1

🧩 Key Takeaways
●​ Pattern: Cycle detection in array using values as indices​

●​ Core Idea: Map array to linked list → find cycle start​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1)​

✅ Final Summary
●​ Approach: Floyd’s Tortoise and Hare on array​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Find duplicate via cycle detection​

Perfect ⚡
​
Next problem in order:

Problem 43: LRU Cache (Overall count: 43/150)

📝 Problem Statement
Design a data structure that follows the Least Recently Used (LRU) cache policy.

●​ Implement LRUCache class with:​

1.​ LRUCache(int capacity) → Initialize cache with given capacity​

2.​ int get(int key) → Return value of key if exists, otherwise -1​

3.​ void put(int key, int value) → Update value if key exists; if not,
add key-value. If capacity exceeded, evict least recently used item​

🔹 Examples
Example 1:

Input

["LRUCache","put","put","get","put","get","put","get","get","get"]

[[2],[1,1],[2,2],[1],[3,3],[2],[4,4],[1],[3],[4]]

Output

[null,null,null,1,null,-1,null,-1,3,4]

💡 Intuition
 ●​ LRU policy → remove least recently used item when capacity exceeded​

●​ Use HashMap + Doubly Linked List:​

○​ HashMap → O(1) access to nodes​

○​ Doubly Linked List → O(1) removal and insertion at head/tail​

🧠 Approach (HashMap + Doubly Linked List)

1.​ Doubly linked list stores cache nodes in usage order (head → most recently used,
tail → least recently used)​

2.​ HashMap maps key → node​

3.​ Operations:​

○​ get(key) → move node to head → return value​

○​ put(key, value) → if exists: update & move to head​

■​ else: create node, insert at head​

■​ if size > capacity → remove tail node​

💻 Java Code with Comments

import java.util.HashMap;

class LRUCache {

class Node {

int key, value;

Node prev, next;

Node(int k, int v) { key = k; value = v; }

}

private int capacity;

private HashMap<Integer, Node> map;

private Node head, tail;

public LRUCache(int capacity) {

this.capacity = capacity;

map = new HashMap<>();

head = new Node(0, 0); // Dummy head

tail = new Node(0, 0); // Dummy tail

head.next = tail;

tail.prev = head;

// Get value of key if exists

public int get(int key) {

if (!map.containsKey(key)) return -1;

Node node = map.get(key);

remove(node); // Remove from current position

insert(node); // Move to head (most recently used)

return node.value;

// Put key-value pair in cache

public void put(int key, int value) {

 if (map.containsKey(key)) {

Node node = map.get(key);

node.value = value;

remove(node);

insert(node);

} else {

if (map.size() == capacity) {

Node lru = tail.prev; // Least recently used

remove(lru);

map.remove(lru.key);

Node node = new Node(key, value);

insert(node);

map.put(key, node);

// Remove node from list

private void remove(Node node) {

node.prev.next = node.next;

node.next.prev = node.prev;

// Insert node right after head

private void insert(Node node) {

node.next = head.next;
 node.prev = head;

head.next.prev = node;

head.next = node;

// Driver code

public static void main(String[] args) {

LRUCache cache = new LRUCache(2);

cache.put(1,1);

cache.put(2,2);

System.out.println(cache.get(1)); // 1

cache.put(3,3); // Evicts key 2

System.out.println(cache.get(2)); // -1

cache.put(4,4); // Evicts key 1

System.out.println(cache.get(1)); // -1

System.out.println(cache.get(3)); // 3

System.out.println(cache.get(4)); // 4

🔍 Dry Run Example

Operations: put(1,1), put(2,2), get(1), put(3,3)

1.​ Add 1→1: list=1​

2.​ Add 2→2: list=2→1​

 3.​ Get 1 → move to head: list=1→2​

4.​ Put 3→3 → capacity exceeded → remove tail (2) → list=3→1 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(1) for get and put using HashMap + doubly linked
list

Space O(capacity) → map + linked list nodes

⚙️ Edge Cases
Case Input Output

Access get(5) -1
non-existent

Update existing put(1,5) updates value & moves to

head

Capacity exceeded put new key evict least recently used

🧩 Key Takeaways
●​ Pattern: HashMap + Doubly Linked List​
 ●​ Core Idea: Maintain order of usage for LRU​

●​ Time Complexity: O(1) per operation​

●​ Space Complexity: O(capacity)​

✅ Final Summary
●​ Approach: Doubly linked list + HashMap​

●​ Time: O(1) per get/put​

●​ Space: O(capacity)​

●​ Pattern: LRU Cache​

Perfect ⚡
​
Next problem in order:

Problem 44: Merge K Sorted Lists (Overall count:

44/150)

📝 Problem Statement
You are given an array of k linked lists, each sorted in ascending order.

●​ Merge all the linked lists into one sorted linked list and return its head.​

🔹 Examples
Example 1:

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

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

Input: lists = []

Output: []

Example 3:

Input: lists = [[]]

Output: []

💡 Intuition
●​ Merge two lists at a time (like merge sort) → simple but slower​

●​ Better → use Priority Queue / Min-Heap to always pick smallest head → efficient​

🧠 Approach (PriorityQueue / Min-Heap)

1.​ Create a min-heap (PriorityQueue) of list nodes based on their val​

2.​ Add the head of each list into the heap​

3.​ While heap is not empty:​

○​ Extract node with smallest value​

○​ Append it to merged list​

○​ If extracted node has next, add next to heap​

4.​ Return dummy.next as head of merged list​

💻 Java Code with Comments

import java.util.PriorityQueue;

// Definition for singly-linked list.

class ListNode {

int val;

ListNode next;

ListNode(int val) { this.val = val; }

public class MergeKSortedLists {

/**

* Merges k sorted linked lists using min-heap.

* @param lists array of ListNode heads

* @return head of merged linked list

*/

public static ListNode mergeKLists(ListNode[] lists) {

if (lists == null || lists.length == 0) return null;

// Min-heap based on node values

PriorityQueue<ListNode> heap = new PriorityQueue<>((a, b) -> a.val -

b.val);

// Add head of each non-empty list

for (ListNode node : lists) {

 if (node != null) heap.offer(node);

ListNode dummy = new ListNode(0);

ListNode tail = dummy;

while (!heap.isEmpty()) {

ListNode node = heap.poll(); // Get smallest node

tail.next = node; // Append to merged list

tail = tail.next;

if (node.next != null) heap.offer(node.next); // Add next node to

heap

return dummy.next;

// Helper function to print linked list

public static void printList(ListNode head) {

ListNode temp = head;

while (temp != null) {

System.out.print(temp.val + " ");

temp = temp.next;

System.out.println();
 }

// Driver code

public static void main(String[] args) {

ListNode l1 = new ListNode(1);

l1.next = new ListNode(4);

l1.next.next = new ListNode(5);

ListNode l2 = new ListNode(1);

l2.next = new ListNode(3);

l2.next.next = new ListNode(4);

ListNode l3 = new ListNode(2);

l3.next = new ListNode(6);

ListNode[] lists = {l1, l2, l3};

ListNode mergedHead = mergeKLists(lists);

System.out.println("Merged List:");

printList(mergedHead); // Output: 1 1 2 3 4 4 5 6

🔍 Dry Run Example

Input: [[1,4,5],[1,3,4],[2,6]]
 ●​ Initialize min-heap with 1,1,2​

●​ Poll 1 → append, add next 4 → heap: 1,2,4​

●​ Poll 1 → append, add next 3 → heap: 2,3,4​

●​ Poll 2 → append, add next 6 → heap: 3,4,6​

●​ Continue → result: 1->1->2->3->4->4->5->6 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(N log k) → N = total nodes, k = number of lists

Space O(k) → heap stores at most k nodes

⚙️ Edge Cases
Case Input Output

Empty array [] []

Array with empty lists [[]] []

Single list [[1,2,3]] [1,2,3]

🧩 Key Takeaways
 ●​ Pattern: Priority Queue (Min-Heap)​

●​ Core Idea: Always pick smallest head → append to result​

●​ Time Complexity: O(N log k)​

●​ Space Complexity: O(k)​

✅ Final Summary
●​ Approach: Min-Heap to merge k sorted lists​

●​ Time: O(N log k)​

●​ Space: O(k)​

●​ Pattern: Merge k sorted lists efficiently​

Perfect! ✅
The code you shared is a recursive implementation of Reverse Nodes in
K-Group. Let me explain it thoroughly with comments, dry run, and complexity analysis.

Problem 45: Reverse Nodes in K Group (Recursive

Implementation)
/**

* Definition for singly-linked list.

* public class ListNode {

* int val;

* ListNode next;

* ListNode() {}

* ListNode(int val) { this.val = val; }

* ListNode(int val, ListNode next) { this.val = val; this.next = next; }

* }
*/

class Solution {

public ListNode reverseKGroup(ListNode head, int k) {

ListNode curr = head;

int count = 0;

// Step 1: Check if there are at least k nodes left

while(curr != null && count != k){

curr = curr.next;

count++;

// Step 2: If we have k nodes, reverse them

if(count == k){

// Recursive call: reverse the rest of the list in k-groups

curr = reverseKGroup(curr, k);

// Reverse current k-group

while(count-- > 0){

ListNode tmp = head.next; // Store next node

head.next = curr; // Point current node to reversed

part

curr = head; // Move curr to current node

head = tmp; // Move head to next node in group

head = curr; // After reversal, curr is new head of this group

 }

// Step 3: Return head (new head after reversing k nodes)

return head;

🔍 Step-by-Step Dry Run

Input: head = [1,2,3,4,5], k = 2

1.​ First group: [1,2] → count = 2 ✅​

2.​ Recursive call on remaining list [3,4,5]​

3.​ Second group: [3,4] → reverse → [4,3]​

4.​ Remaining node [5] → less than k → keep as is​

5.​ Connect reversed groups: [2,1] -> [4,3] -> 5​

6.​ Output: [2,1,4,3,5] ✅​

💡 Intuition
●​ Recursive idea: Reverse the first k nodes, then recursively reverse the rest.​

●​ In-place reversal: Adjust pointers inside the while loop.​

●​ Termination: If less than k nodes → stop reversing.​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n) → each node visited exactly once

Space O(n/k) → recursion stack for each k-group

⚙️ Edge Cases
Case Input Output

Less than k [1,2,3], k=5 [1,2,3]

nodes

Single node [1], k=1 [1]

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

Empty list [], k=2 []

🧩 Key Takeaways
●​ Pattern: Recursive reversal of k nodes​

●​ Core Idea: Reverse first k nodes → recursively reverse rest → connect​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(n/k) due to recursion​

7. Heaps

Problem 46: Kth Largest Element in a Stream (Overall

count: 46/150)

📝 Problem Statement
Design a class to find the kth largest element in a stream of numbers.

●​ Implement KthLargest class:​

1.​ KthLargest(int k, int[] nums) → Initialize with integer k and integer

array nums​

2.​ int add(int val) → Add val to the stream and return the kth largest
element​

Note: The kth largest element is the kth largest element in sorted order, not the kth
distinct element.

🔹 Examples
Example:

Input

["KthLargest","add","add","add","add","add"]

[[3,[4,5,8,2]],[3],[5],[10],[9],[4]]

Output

[null,4,5,5,8,8]

💡 Intuition
 ●​ Always maintain a min-heap of size k​

●​ The root of the heap is the kth largest element​

●​ Steps:​

1.​ Add all initial elements to heap​

2.​ If heap size > k → remove min (root)​

3.​ For add(val) → insert → remove min if size > k → return root​

Why min-heap?

●​ The smallest element in the heap is the kth largest among all elements seen so far​

🧠 Approach (Min-Heap)
1.​ Initialize PriorityQueue heap (min-heap)​

2.​ Add all elements from nums into the heap​

○​ Maintain size ≤ k​

3.​ For each add(val):​

○​ Add val to heap​

○​ If size > k → remove root​

○​ Return root → kth largest element​

💻 Java Code with Comments

import java.util.PriorityQueue;

class KthLargest {

private PriorityQueue<Integer> minHeap;

private int k;

public KthLargest(int k, int[] nums) {

this.k = k;

minHeap = new PriorityQueue<>();

// Add initial numbers to heap

for (int num : nums) {

add(num);

public int add(int val) {

minHeap.offer(val); // Add new value

// Maintain heap size <= k

if (minHeap.size() > k) {

minHeap.poll(); // Remove smallest

// Root of min-heap is kth largest element

return minHeap.peek();

// Driver code

public static void main(String[] args) {

 int[] nums = {4,5,8,2};

KthLargest kthLargest = new KthLargest(3, nums);

System.out.println(kthLargest.add(3)); // 4

System.out.println(kthLargest.add(5)); // 5

System.out.println(kthLargest.add(10)); // 5

System.out.println(kthLargest.add(9)); // 8

System.out.println(kthLargest.add(4)); // 8

🔍 Dry Run Example

Initial array: [4,5,8,2], k=3

●​ Heap after initialization (size ≤ k): [4,5,8] → root = 4 (3rd largest)​

●​ add(3) → heap [3,4,5,8] → remove min 3 → heap [4,5,8] → return 4​

●​ add(5) → heap [4,5,5,8] → remove min 4 → heap [5,5,8] → return 5​

●​ add(10) → heap [5,5,8,10] → remove min 5 → heap [5,10,8] → return 5​

●​ add(9) → heap [5,9,8,10] → remove min 5 → heap [8,9,10] → return 8​

✅ Works perfectly

📊 Complexity Analysis
Aspec Complexity
t
Time O(log k) per add → insertion and removal in
heap

Space O(k) → heap stores at most k elements

⚙️ Edge Cases
Case Input Output

Empty initial array k=3, nums=[] Returns value after add calls

Less than k k=3, nums=[2] Maintains heap until enough

elements elements

🧩 Key Takeaways
●​ Pattern: Min-heap to maintain k largest elements​

●​ Core Idea: Min-heap root = kth largest​

●​ Time Complexity: O(log k) per add​

●​ Space Complexity: O(k)​

✅ Final Summary
●​ Approach: Min-Heap of size k​

●​ Time: O(log k) per add()​

●​ Space: O(k)​
 ●​ Pattern: Stream processing with heaps​

Perfect ⚡​
Next problem in order:

Problem 47: Last Stone Weight (Overall count: 47/150)

📝 Problem Statement
You are given an array stones where stones[i] is the weight of the i-th stone.

●​ Each turn, choose the two heaviest stones and smash them together:​

○​ If they are equal, both stones are destroyed​

○​ If they are unequal, the smaller stone is destroyed and the larger stone's
weight is reduced by the smaller stone's weight​

●​ Continue until at most one stone remains​

●​ Return the weight of the last stone, or 0 if none remain​

🔹 Examples
Example 1:

Input: stones = [2,7,4,1,8,1]

Output: 1

Explanation:

- Smash 8 and 7 → new stone 1 → [2,4,1,1,1]

- Smash 4 and 2 → new stone 2 → [2,1,1,1]

- Smash 2 and 1 → new stone 1 → [1,1,1]

- Smash 1 and 1 → destroyed → [1]

Example 2:

Input: stones = [1]

Output: 1

💡 Intuition
●​ We always need the two heaviest stones → perfect for max-heap​

●​ Use PriorityQueue in Java with reverse order (max-heap)​

●​ Keep smashing until ≤1 stone remains​

🧠 Approach (Max-Heap)
1.​ Create max-heap and add all stones​

2.​ While heap size > 1:​

○​ Extract two largest stones: stone1, stone2​

○​ If stone1 != stone2 → insert stone1 - stone2 back into heap​

3.​ Return 0 if heap is empty, else heap.peek()​

💻 Java Code with Comments

import java.util.PriorityQueue;

import java.util.Collections;

public class LastStoneWeight {

public static int lastStoneWeight(int[] stones) {

 // Max-heap using reverse order comparator

PriorityQueue<Integer> maxHeap = new

PriorityQueue<>(Collections.reverseOrder());

// Add all stones to heap

for (int stone : stones) {

maxHeap.offer(stone);

// Smash stones until <=1 remains

while (maxHeap.size() > 1) {

int stone1 = maxHeap.poll(); // Heaviest

int stone2 = maxHeap.poll(); // Second heaviest

if (stone1 != stone2) {

maxHeap.offer(stone1 - stone2); // Add remaining weight

return maxHeap.isEmpty() ? 0 : maxHeap.peek();

// Driver code

public static void main(String[] args) {

int[] stones1 = {2,7,4,1,8,1};

System.out.println("Last Stone Weight: " + lastStoneWeight(stones1));

// 1
 int[] stones2 = {1};

System.out.println("Last Stone Weight: " + lastStoneWeight(stones2));

// 1

🔍 Dry Run Example

Input: [2,7,4,1,8,1]

●​ Max-heap: [8,7,4,2,1,1]​

●​ Pop 8,7 → difference 1 → heap [4,2,1,1,1]​

●​ Pop 4,2 → difference 2 → heap [2,1,1,1]​

●​ Pop 2,1 → difference 1 → heap [1,1,1]​

●​ Pop 1,1 → destroyed → heap [1]​

●​ Return 1 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n log n) → each stone inserted/removed in

heap

Space O(n) → max-heap stores all stones

⚙️ Edge Cases
Case Input Output

Single stone [5] 5

All stones equal [3,3,3,3] 0

Two stones [10,3] 7

🧩 Key Takeaways
●​ Pattern: Use max-heap to always select largest elements​

●​ Core Idea: Simulate smashing using heap efficiently​

●​ Time Complexity: O(n log n)​

●​ Space Complexity: O(n)​

✅ Final Summary
●​ Approach: Max-Heap​

●​ Time: O(n log n)​

●​ Space: O(n)​

●​ Pattern: Greedy selection with heap​

Perfect⚡ ​
Next problem in order:
Problem 48: K Closest Points to Origin (Overall count:
48/150)

📝 Problem Statement
Given an array of points points[i] = [xi, yi] on a 2D plane and an integer k,

●​ Return the k points closest to the origin (0,0).​

●​ The distance is Euclidean distance: sqrt(xi^2 + yi^2).​

●​ You may return the answer in any order.​

🔹 Examples
Example 1:

Input: points = [[1,3],[-2,2]], k = 1

Output: [[-2,2]]

Explanation:

Distance: [sqrt(10), sqrt(8)] → closest is [-2,2]

Example 2:

Input: points = [[3,3],[5,-1],[-2,4]], k = 2

Output: [[3,3],[-2,4]]

💡 Intuition
●​ Need k smallest distances → perfect for heap​

●​ Use a max-heap of size k:​

 ○​ Keep k closest points​

○​ If new point closer than current max → replace root​

Why max-heap?

●​ We want to discard farthest when heap size exceeds k​

🧠 Approach (Max-Heap of size k)

1.​ Create PriorityQueue<int[]> heap with comparator: distance squared​

○​ Max-heap → largest distance at root​

2.​ Iterate points:​

○​ Add point to heap​

○​ If heap size > k → remove root (farthest point)​

3.​ Heap contains k closest points​

4.​ Return all points from heap​

Note: Use distance squared to avoid sqrt → saves computation

💻 Java Code with Comments

import java.util.PriorityQueue;

public class KClosestPoints {

public static int[][] kClosest(int[][] points, int k) {

// Max-heap: compare by distance squared from origin

PriorityQueue<int[]> maxHeap = new PriorityQueue<>(

 (a, b) -> Integer.compare(distanceSquared(b), distanceSquared(a))

);

for (int[] point : points) {

maxHeap.offer(point);

// Maintain heap size k

if (maxHeap.size() > k) {

maxHeap.poll(); // Remove farthest point

// Extract k closest points

int[][] result = new int[k][2];

int index = 0;

while (!maxHeap.isEmpty()) {

result[index++] = maxHeap.poll();

return result;

// Helper: distance squared from origin

private static int distanceSquared(int[] point) {

return point[0]*point[0] + point[1]*point[1];

}
 // Driver code

public static void main(String[] args) {

int[][] points = {{1,3},{-2,2},{5,8},{0,1}};

int k = 2;

int[][] closest = kClosest(points, k);

System.out.println("K Closest Points:");

for (int[] p : closest) {

System.out.println("[" + p[0] + "," + p[1] + "]");

🔍 Dry Run Example

Input: points=[[1,3],[-2,2],[5,8],[0,1]], k=2

●​ Heap operations:​

1.​ Add [1,3] → heap [1,3]​

2.​ Add [-2,2] → heap [-2,2],[1,3] → size=2 ✅​

3.​ Add [5,8] → heap size>k → remove farthest [5,8]​

4.​ Add [0,1] → heap contains [0,1],[-2,2] → final result​

Output: [[-2,2],[0,1]] ✅

📊 Complexity Analysis
 Aspec Complexity
t

Time O(n log k) → each insert/removal in heap of size k

Space O(k) → max-heap stores k points

⚙️ Edge Cases
Case Input Output

k=n all points return all points

k=0 any points return empty array

Points with same [[1,1],[-1,-1]], k=1 any one of closest

distance points

🧩 Key Takeaways
●​ Pattern: Max-heap of size k → maintain k smallest elements​

●​ Core Idea: Remove farthest when heap exceeds k​

●​ Time Complexity: O(n log k)​

●​ Space Complexity: O(k)​

✅ Final Summary
 ●​ Approach: Max-Heap for k closest points​

●​ Time: O(n log k)​

●​ Space: O(k)​

●​ Pattern: Heap / Priority Queue​

Perfect ⚡​
Next problem in order:

Problem 49: Kth Largest Element in an Array (Overall

count: 49/150)

📝 Problem Statement
Given an integer array nums and an integer k,

●​ Return the kth largest element in the array.​

●​ Note: It is the kth largest element in sorted order, not the kth distinct element.​

🔹 Examples
Example 1:

Input: nums = [3,2,1,5,6,4], k = 2

Output: 5

Example 2:

Input: nums = [3,2,3,1,2,4,5,5,6], k = 4

Output: 4
💡 Intuition
●​ We want the kth largest element → similar to stream kth largest​

●​ Approach 1 (Heap): Min-heap of size k → root is kth largest​

●​ Approach 2 (QuickSelect): Partition array like quicksort → find kth largest in O(n)
average​

We will use Min-Heap for simplicity.

🧠 Approach (Min-Heap)
1.​ Create min-heap (PriorityQueue)​

2.​ Add elements from nums to heap:​

○​ If heap size > k → remove min​

3.​ After all insertions, heap root = kth largest element​

💻 Java Code with Comments

import java.util.PriorityQueue;

public class KthLargestElement {

public static int findKthLargest(int[] nums, int k) {

// Min-heap to store k largest elements

PriorityQueue<Integer> minHeap = new PriorityQueue<>();

 for (int num : nums) {

minHeap.offer(num); // Add number

// Maintain heap size <= k

if (minHeap.size() > k)

minHeap.poll(); // Remove smallest among heap

// Root of min-heap is kth largest

return minHeap.peek();

// Driver code

public static void main(String[] args) {

int[] nums1 = {3,2,1,5,6,4};

int k1 = 2;

System.out.println("Kth Largest: " + findKthLargest(nums1, k1)); //

Output: 5

int[] nums2 = {3,2,3,1,2,4,5,5,6};

int k2 = 4;

System.out.println("Kth Largest: " + findKthLargest(nums2, k2)); //

Output: 4

}
🔍 Dry Run Example
Input: nums=[3,2,1,5,6,4], k=2

●​ Min-heap operations:​

1.​ Add 3 → heap [3]​

2.​ Add 2 → heap [2,3] size=k ✅​

3.​ Add 1 → heap [1,3,2] → size>k → remove 1 → heap [2,3]​

4.​ Add 5 → heap [2,3,5] → remove 2 → heap [3,5]​

5.​ Add 6 → heap [3,5,6] → remove 3 → heap [5,6]​

6.​ Add 4 → heap [4,6,5] → remove 4 → heap [5,6]​

●​ Root = 5 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n log k) → heap insert/removal for n elements

Space O(k) → heap stores k largest elements

⚙️ Edge Cases
Case Input Output
 k=1 nums=[1,2,3] 3

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

Array with duplicates nums=[2,2,3,3], k=3 2

🧩 Key Takeaways
●​ Pattern: Min-heap to maintain k largest elements​

●​ Core Idea: Heap root = kth largest​

●​ Time Complexity: O(n log k)​

●​ Space Complexity: O(k)​

✅ Final Summary
●​ Approach: Min-Heap of size k​

●​ Time: O(n log k)​

●​ Space: O(k)​

●​ Pattern: Heap / Priority Queue​

Perfect⚡ ​
Next problem in order:

Problem 50: Task Scheduler (Overall count: 50/150)

📝 Problem Statement
You are given a char array tasks representing tasks 'A' to 'Z' and a non-negative
integer n representing the cooling interval between two same tasks.

●​ You can execute one task per unit time​

●​ You may insert idle intervals if necessary​

●​ Return the least number of units of time needed to finish all tasks​

🔹 Examples
Example 1:

Input: tasks = ['A','A','A','B','B','B'], n = 2

Output: 8

Explanation: A -> B -> idle -> A -> B -> idle -> A -> B

Example 2:

Input: tasks = ['A','A','A','B','B','B'], n = 0

Output: 6

Explanation: No cooling needed → execute sequentially

💡 Intuition
●​ Identify task with maximum frequency → determines minimum time​

●​ Maximum frequency task creates blocks of size n+1​

●​ Idle time inserted if not enough different tasks to fill blocks​

Pattern: Greedy + Counting

🧠 Approach
1.​ Count frequency of each task​

2.​ Find max frequency (f_max)​

3.​ Count tasks with max frequency (maxCount)​

4.​ Minimum intervals = Math.max(tasks.length, (f_max - 1) * (n + 1) +

maxCount)​

Explanation:

●​ (f_max - 1) * (n + 1) → full blocks of most frequent task​

●​ + maxCount → last block​

●​ Math.max() → handles case where no idle needed​

💻 Java Code with Comments

import java.util.*;

public class TaskScheduler {

public static int leastInterval(char[] tasks, int n) {

int[] freq = new int[26];

// Count frequency of tasks

for (char task : tasks) {

freq[task - 'A']++;

}
 Arrays.sort(freq); // Sort ascending

int f_max = freq[25]; // Max frequency

int maxCount = 0;

// Count how many tasks have max frequency

for (int f : freq) {

if (f == f_max) maxCount++;

// Formula for minimum intervals

return Math.max(tasks.length, (f_max - 1) * (n + 1) + maxCount);

// Driver code

public static void main(String[] args) {

char[] tasks1 = {'A','A','A','B','B','B'};

int n1 = 2;

System.out.println("Least Interval: " + leastInterval(tasks1, n1));

// 8

char[] tasks2 = {'A','A','A','B','B','B'};

int n2 = 0;

System.out.println("Least Interval: " + leastInterval(tasks2, n2));

// 6

}
🔍 Dry Run Example
Input: tasks=['A','A','A','B','B','B'], n=2

●​ Frequency: A=3, B=3​

●​ Max freq f_max=3, tasks with max freq = 2​

●​ Minimum intervals: (3-1)*(2+1)+2 = 2*3+2 = 8 ✅​

📊 Complexity Analysis
Aspec Complexity
t

Time O(n + 26) → counting + sorting 26 elements ≈ O(n)

Space O(26) → frequency array

⚙️ Edge Cases
Case Input Output

No cooldown n=0 Answer = tasks.length

Single task tasks=['A'], n=2 1

All tasks tasks=['A','A','A'], n=2 7

same
🧩 Key Takeaways
●​ Pattern: Greedy + counting + formula​

●​ Core Idea: Maximum frequency task determines block structure​

●​ Time Complexity: O(n)​

●​ Space Complexity: O(1) → only 26 letters​

✅ Final Summary
●​ Approach: Frequency + formula for idle slots​

●​ Time: O(n)​

●​ Space: O(1)​

●​ Pattern: Heap / Counting / Greedy​

Perfect ⚡​
Next problem in order:

Problem 51: Design Twitter (Overall count: 51/150)

📝 Problem Statement
Design a simplified version of Twitter. Implement the following functionality:

1.​ postTweet(userId, tweetId) → Compose a new tweet​

2.​ getNewsFeed(userId) → Retrieve the 10 most recent tweet IDs in the user’s
news feed.​

○​ Tweets must be ordered from most recent to least recent​

 ○​ Include tweets from the user and users they follow​

3.​ follow(followerId, followeeId) → Follower follows a followee​

4.​ unfollow(followerId, followeeId) → Follower unfollows a followee​

💡 Intuition
●​ Maintain mapping of user → list of tweets​

●​ Maintain mapping of user → set of followees​

●​ For getNewsFeed:​

○​ Collect tweets from self + followees​

○​ Use max-heap to efficiently get most recent tweets​

Pattern: HashMap + PriorityQueue

🧠 Approach
1.​ Use HashMap<Integer, Set> followers → followee sets​

2.​ Use HashMap<Integer, List> tweets → list of tweets per user​

○​ Tweet contains tweetId and timestamp​

3.​ Maintain a global timestamp increasing with each new tweet​

4.​ postTweet: add tweet to user's list with timestamp​

5.​ follow / unfollow: update followers map​

6.​ getNewsFeed:​

○​ Use max-heap on timestamps​

○​ Collect tweets from user + followees​

 ○​ Return 10 most recent tweet IDs​

💻 Java Code with Comments

import java.util.*;

class Twitter {

private static int timestamp = 0; // Global timestamp to order tweets

// Tweet class stores tweet id and timestamp

class Tweet {

int id;

int time;

Tweet(int id, int time) {

this.id = id;

this.time = time;

// Map each user to a set of users they follow

private Map<Integer, Set<Integer>> followers;

// Map each user to a list of their tweets

private Map<Integer, List<Tweet>> tweets;

 // Constructor initializes maps

public Twitter() {

followers = new HashMap<>();

tweets = new HashMap<>();

// Post a tweet for a user

public void postTweet(int userId, int tweetId) {

// If user has no tweet list, create one

tweets.putIfAbsent(userId, new ArrayList<>());

// Add new tweet with current timestamp

tweets.get(userId).add(new Tweet(tweetId, timestamp++));

// Retrieve the 10 most recent tweets in the user's news feed

public List<Integer> getNewsFeed(int userId) {

// Max-heap to sort tweets by timestamp descending

PriorityQueue<Tweet> maxHeap = new PriorityQueue<>((a,b) -> b.time -

a.time);

// Get the set of followees for this user

Set<Integer> followees = followers.getOrDefault(userId, new

HashSet<>());

followees.add(userId); // Include the user's own tweets

// Add all tweets of user and followees into the heap

for (int f : followees) {

 List<Tweet> userTweets = tweets.getOrDefault(f, new
ArrayList<>());

maxHeap.addAll(userTweets);

// Extract up to 10 most recent tweet IDs

List<Integer> feed = new ArrayList<>();

int count = 0;

while (!maxHeap.isEmpty() && count < 10) {

feed.add(maxHeap.poll().id);

count++;

return feed; // Return the news feed

// User follows another user

public void follow(int followerId, int followeeId) {

if (followerId == followeeId) return; // Cannot follow self

// If follower has no followee set, create one

followers.putIfAbsent(followerId, new HashSet<>());

followers.get(followerId).add(followeeId); // Add followee

// User unfollows another user

public void unfollow(int followerId, int followeeId) {

 if (followers.containsKey(followerId)) {

followers.get(followerId).remove(followeeId); // Remove followee

// Driver code to test Twitter implementation

public static void main(String[] args) {

Twitter twitter = new Twitter();

// User 1 posts a tweet 5

twitter.postTweet(1, 5);

System.out.println(twitter.getNewsFeed(1)); // Output: [5]

// User 1 follows user 2

twitter.follow(1, 2);

// User 2 posts tweet 6

twitter.postTweet(2, 6);

System.out.println(twitter.getNewsFeed(1)); // Output: [6,5]

// User 1 unfollows user 2

twitter.unfollow(1,2);

System.out.println(twitter.getNewsFeed(1)); // Output: [5]

}
✅ Added Comments Explanation
1.​ Global timestamp → ensures correct order of tweets​

2.​ Tweet class → encapsulates tweet id and timestamp​

3.​ followers map → tracks follow relationships​

4.​ tweets map → stores each user’s tweets​

5.​ postTweet → adds tweet with timestamp​

6.​ getNewsFeed → max-heap gathers most recent tweets efficiently​

7.​ follow/unfollow → manages relationships​

8.​ Driver code → demonstrates all operations step by step

🔍 Dry Run Example

●​ User 1 posts tweet 5 → news feed [5]​

●​ User 1 follows user 2​

●​ User 2 posts tweet 6 → news feed [6,5] (most recent first)​

●​ User 1 unfollows user 2 → news feed [5]​

📊 Complexity Analysis
Operation Time Space

postTweet O(1) O(1) per tweet

follow/unfollow O(1) O(followees)

getNewsFeed O(f log t) O(f * t) for heap

●​ ​
f = number of followees + 1, t = tweets per followee​

⚙️ Edge Cases
Case Behavior

Follow self Ignored

Unfollow non-followed user Ignored

No tweets Return empty list

🧩 Key Takeaways
●​ Pattern: HashMap + PriorityQueue (Heap)​

●​ Core Idea: Use max-heap to get most recent 10 tweets​

●​ Time Complexity: O(f log t) per news feed query​

●​ Space Complexity: O(u + n) → users + total tweets​

✅ Final Summary
●​ Approach: HashMap for tweets & followers + max-heap for news feed​

●​ Pattern: Heap + HashMap + Greedy​

 ●​ Efficient for: Streamed updates + top recent queries​

Perfect⚡ ​
Next problem in order:

Problem 52: Find Median from Data Stream (Overall

count: 52/150)

📝 Problem Statement
Design a data structure that supports adding numbers from a data stream and finding the
median efficiently:

●​ addNum(int num) → Add a number to the data stream​

●​ findMedian() → Return the median of all elements so far​

Median Definition:

●​ Odd number of elements → middle element​

●​ Even number of elements → average of two middle elements​

💡 Intuition
●​ Median → middle element → needs ordered access​

●​ Idea: Use two heaps:​

○​ Max-heap → left half (smaller numbers)​

○​ Min-heap → right half (larger numbers)​

●​ Invariant:​
 ○​ Max-heap size == Min-heap size OR Max-heap size = Min-heap size + 1​

○​ Median = root of max-heap (if odd) or average of roots (if even)​

🧠 Approach (Two Heaps)

1.​ Max-heap stores smaller half → largest at top​

2.​ Min-heap stores larger half → smallest at top​

3.​ When adding a number:​

○​ Add to max-heap first​

○​ Move top of max-heap to min-heap​

○​ Balance heaps (max-heap can have 1 more element than min-heap)​

4.​ To find median:​

○​ If sizes equal → average of two tops​

○​ Else → top of max-heap​

💻 Java Code with Comments

import java.util.PriorityQueue;

public class MedianFinder {

// Max-heap for smaller half

private PriorityQueue<Integer> maxHeap;

// Min-heap for larger half

private PriorityQueue<Integer> minHeap;

 // Constructor

public MedianFinder() {

maxHeap = new PriorityQueue<>((a,b) -> b - a); // Max-heap

minHeap = new PriorityQueue<>(); // Min-heap

// Add number to data structure

public void addNum(int num) {

maxHeap.offer(num); // Add to max-heap

minHeap.offer(maxHeap.poll()); // Move largest from max-heap to

min-heap

// Balance heaps: max-heap can have at most 1 more element

if (maxHeap.size() < minHeap.size()) {

maxHeap.offer(minHeap.poll());

// Find median

public double findMedian() {

if (maxHeap.size() == minHeap.size()) {

// Even number of elements → average of two middles

return (maxHeap.peek() + minHeap.peek()) / 2.0;

} else {

// Odd → max-heap has the extra element

return maxHeap.peek();
 }

// Driver code

public static void main(String[] args) {

MedianFinder mf = new MedianFinder();

mf.addNum(1);

mf.addNum(2);

System.out.println("Median: " + mf.findMedian()); // 1.5

mf.addNum(3);

System.out.println("Median: " + mf.findMedian()); // 2.0

mf.addNum(4);

mf.addNum(5);

System.out.println("Median: " + mf.findMedian()); // 3.0

🔍 Dry Run Example

Input stream: [1,2,3,4,5]

1.​ Add 1 → maxHeap [1], minHeap [] → median 1​

2.​ Add 2 → maxHeap [1], minHeap [2] → median (1+2)/2 = 1.5​

3.​ Add 3 → maxHeap [2,1], minHeap [3] → median 2​

 4.​ Add 4 → maxHeap [2,1], minHeap [3,4] → median (2+3)/2 = 2.5​

5.​ Add 5 → maxHeap [3,2,1], minHeap [4,5] → median 3 ✅​

📊 Complexity Analysis
Operation Time Spac
e

addNum O(log n) → insert + rebalance O(n)

findMedian O(1) O(n)

●​ ​
n = total numbers added so far​

⚙️ Edge Cases
Case Behavior

Single element Median = element itself

Even elements Median = average of two middle

elements

Negative Works correctly with heaps

numbers

🧩 Key Takeaways
 ●​ Pattern: Two Heaps → max-heap + min-heap​

●​ Core Idea: Keep halves balanced to get median efficiently​

●​ Time Complexity: O(log n) per insertion, O(1) for median​

●​ Space Complexity: O(n) for storing all numbers​

✅ Final Summary
●​ Approach: Two Heaps (Max-heap for left half, Min-heap for right half)​

●​ Efficient median finding in a data stream​

●​ Pattern: Heap / Priority Queue + Greedy​

8. BackTracking

Perfect ⚡ Let's begin the Backtracking section with:

🧩 Problem 53: Subsets (Overall Count: 53 / 150)

📝 Problem Statement
Given an integer array nums of unique elements, return all possible subsets (the power
set).

The solution must not contain duplicate subsets, and subsets can be returned in any
order.

🔹 Example 1
Input: nums = [1,2,3]

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

🔹 Example 2
Input: nums = [0]

Output: [[], [0]]

💡 Intuition
●​ For each element, we have 2 choices:​

1.​ Include it in the subset​

2.​ Exclude it​

●​ This leads to 2ⁿ total subsets (where n = number of elements)​

We use backtracking to systematically explore all choices:

1.​ Start from an empty list []​

2.​ At each step, choose whether to add the next number​

3.​ Recurse forward​

4.​ Backtrack (remove last number) to explore next possibility​

🧠 Approach
1.​ Use a helper function backtrack(start, path)​

○​ start: current index in the array​

○​ path: current subset being built​

 2.​ Add the current path to the result (it’s a valid subset at every step)​

3.​ Loop through nums starting from start:​

○​ Add element to path​

○​ Recurse (backtrack(i + 1, path))​

○​ Remove last element (backtrack step)​

💻 Java Code (With Detailed Comments)

import java.util.*;

public class Subsets {

public static List<List<Integer>> subsets(int[] nums) {

List<List<Integer>> result = new ArrayList<>();

backtrack(0, nums, new ArrayList<>(), result);

return result;

// Backtracking helper function

private static void backtrack(int start, int[] nums, List<Integer> path,

List<List<Integer>> result) {

// 1️⃣ Every path (including empty one) is a valid subset

result.add(new ArrayList<>(path));

// 2️⃣ Explore further elements starting from 'start' index

for (int i = start; i < nums.length; i++) {

 // Choose the current number

path.add(nums[i]);

// Recurse with next index

backtrack(i + 1, nums, path, result);

// Undo the choice (backtrack)

path.remove(path.size() - 1);

// Driver code

public static void main(String[] args) {

int[] nums = {1, 2, 3};

List<List<Integer>> subsets = subsets(nums);

System.out.println("All Subsets:");

for (List<Integer> subset : subsets) {

System.out.println(subset);

🔍 Dry Run Example

Input: nums = [1, 2]
 Step Path Action
(Subset)

Start [] Add to result

Choose 1 [1] Add to result

Choose 2 [1, 2] Add to result

Backtrack [1] → [] Remove 2

Skip 1 → Choose [2] Add to result

2

Backtrack [2] → [] Remove 2

✅ Output: [[], [1], [1,2], [2]]

📊 Complexity Analysis
Aspect Complexity Explanation

Time O(n × 2ⁿ) Each subset copied (up to n elements, total 2ⁿ

subsets)

Space O(n) Recursion stack depth (max path length)

Output O(n × 2ⁿ) For storing all subsets

Space
⚙️ Edge Cases
Input Output

[] [[]]

[1] [[],
[1]]

[1,2,3] 8 subsets

Negative Works fine

numbers

🧩 Key Takeaways
●​ Pattern: Backtracking​

●​ Core Idea: Explore all include/exclude possibilities recursively​

●​ Result: 2ⁿ subsets generated​

●​ Backtrack step is critical to remove last added element​

✅ Final Summary
Concept Description

Approach Recursive backtracking (DFS)

 Complexity O(n × 2ⁿ) time, O(n) space

Pattern Subset generation using

recursion

Key step Add → Recurse → Remove

Perfect ⚡​
Let’s move to the next one — continuing our Backtracking section!

🧩 Problem 54: Combination Sum (Overall Count: 54 /

150)

📝 Problem Statement
Given an array of distinct integers candidates and a target integer target,​
return a list of all unique combinations of candidates where the chosen numbers sum
to target.

You may use the same number from candidates an unlimited number of times.

Return the combinations in any order.

🔹 Example 1
Input: candidates = [2,3,6,7], target = 7

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

Explanation:

2+2+3=7

7=7
🔹 Example 2
Input: candidates = [2,3,5], target = 8

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

🔹 Example 3
Input: candidates = [2], target = 1

Output: []

💡 Intuition
We must find all combinations of numbers that sum up to a given target.​
Each number can be used repeatedly, which makes it a backtracking problem.

At each recursive step:

1.​ We pick a candidate number.​

2.​ Either include it (and reduce target by that number), or skip it.​

3.​ Continue exploring until:​

○​ The target becomes 0 → valid combination​

○​ The target becomes negative → invalid path (backtrack)​

🧠 Approach
1.​ Sort candidates (optional, but helps with pruning).​

Use a recursive helper function:​

​
backtrack(start, target, path, result)
 2.​
○​ start: index to control reuse of numbers​

○​ target: remaining sum to reach​

○​ path: current combination​

○​ result: list of all valid combinations​

3.​ If target == 0, add a copy of path to result.​

4.​ If target < 0, backtrack.​

5.​ For each candidate starting at start:​

○​ Add it to path.​

○​ Recurse with updated target - candidate.​

○​ Remove it after recursion (backtrack).​

💻 Java Code (With Detailed Comments)

import java.util.*;

public class CombinationSum {

public static List<List<Integer>> combinationSum(int[] candidates, int

target) {

List<List<Integer>> result = new ArrayList<>();

backtrack(0, candidates, target, new ArrayList<>(), result);

return result;

// Backtracking helper
 private static void backtrack(int start, int[] candidates, int target,

List<Integer> path, List<List<Integer>>

result) {

// 1️⃣ Base case: when target == 0, we found a valid combination

if (target == 0) {

result.add(new ArrayList<>(path));

return;

// 2️⃣ Base case: if target < 0, this path is invalid → stop exploring

if (target < 0) return;

// 3️⃣ Explore all possible candidates

for (int i = start; i < candidates.length; i++) {

// Choose the current number

path.add(candidates[i]);

// Recurse: same 'i' because we can reuse same number

backtrack(i, candidates, target - candidates[i], path, result);

// Undo choice → Backtrack

path.remove(path.size() - 1);

}
 // Driver code

public static void main(String[] args) {

int[] candidates = {2, 3, 6, 7};

int target = 7;

List<List<Integer>> combinations = combinationSum(candidates,

target);

System.out.println("Combinations that sum to target:");

for (List<Integer> comb : combinations) {

System.out.println(comb);

🔍 Dry Run Example

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

Step Path Remaining Target Action

Start [] 7 —

Choose 2 [2] 5 Recurse

Choose 2 [2,2] 3 Recurse

again
Choose 2 [2,2,2] 1 Recurse
again

Choose 2 [2,2,2,2] -1 ❌ Invalid → Backtrack

again

Choose 3 [2,2,3] 0 ✅ Valid → Add to result

Backtrack [2,2] — Remove 3

Backtrack [2] — Remove 2

Choose 3 [3] 4 Recurse

Choose 3 [3,3] 1 Recurse

again

Choose 3 [3,3,3] -2 ❌ Invalid → Backtrack

again

Backtrack [3] — Remove 3

Choose 6 [6] 1 ❌ Invalid

Choose 7 [7] 0 ✅ Valid → Add to result
✅ Final result: [[2,2,3],[7]]

📊 Complexity Analysis
 Aspect Complexity Explanation

Time O(2ⁿ) Exponential: each number may be

included/excluded many times

Space O(target) Recursion depth proportional to target value

Output Depends on # of valid

Space combinations

⚙️ Edge Cases
Input Output Reason

[2,3,6,7] [[2,2,3],[ Basic

, 7 7]]

[2], 1 [] No valid combos

[1], 2 [[1,1]] Can reuse

element

[], 3 [] Empty input

🧩 Key Takeaways
●​ Backtracking pattern: include/exclude candidate, then recurse.​

●​ Reusing same element → pass same index again.​

 ●​ Stop recursion when target < 0 or target == 0.​

●​ Add copy of path (not reference!) to result list.​

✅ Final Summary
Concept Description

Approach Backtracking with reusing candidates

Time Complexity O(2ⁿ) (exponential)

Space O(target) recursion depth

Complexity

Core Step Add → Recurse → Remove (Backtrack)

Use Case When elements can be reused multiple

times

Perfect😎 ​
Let’s move ahead with the next one in the Backtracking section!

🧩 Problem 55: Combination Sum II (Overall Count: 55 /

150)

📝 Problem Statement
Given a collection of candidate numbers candidates (which may contain duplicates)
and a target number target,​
find all unique combinations in candidates where the candidate numbers sum to
target.

Each number in candidates may only be used once in the combination.​

Return the solution set without duplicate combinations.

🔹 Example 1
Input: candidates = [10,1,2,7,6,1,5], target = 8

Output: [[1,1,6],[1,2,5],[1,7],[2,6]]

🔹 Example 2
Input: candidates = [2,5,2,1,2], target = 5

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

💡 Intuition
This problem is similar to Combination Sum I,​
but with two key differences:

1.​ Each element can be used only once.​

2.​ Input may contain duplicates, but we must return unique combinations.​

To handle duplicates:

●​ We sort the array first.​

●​ While iterating, if we encounter the same number as the previous one (and it's not
the first in that level), we skip it.​

🧠 Approach
 1.​ Sort the candidates array — helps detect duplicates easily.​

2.​ Use backtracking:​

○​ If target == 0, add current path as valid combination.​

○​ If target < 0, stop exploring (no valid solution).​

3.​ Loop from current index i = start to end:​

○​ If current number is same as previous (and i > start), skip it.​

○​ Add the current number.​

○​ Recurse with next index (i + 1) since we can’t reuse same number.​

○​ Backtrack (remove last added number).​

💻 Java Code (With Detailed Comments)

import java.util.*;

public class CombinationSumII {

public static List<List<Integer>> combinationSum2(int[] candidates, int

target) {

List<List<Integer>> result = new ArrayList<>();

Arrays.sort(candidates); // Sort to handle duplicates easily

backtrack(0, candidates, target, new ArrayList<>(), result);

return result;

// Backtracking helper function

private static void backtrack(int start, int[] candidates, int target,

 List<Integer> path, List<List<Integer>>
result) {

// 1️⃣ Base case: found a valid combination

if (target == 0) {

result.add(new ArrayList<>(path));

return;

// 2️⃣ Explore all numbers from 'start' index

for (int i = start; i < candidates.length; i++) {

// Skip duplicates: if current number is same as previous in this

level

if (i > start && candidates[i] == candidates[i - 1]) continue;

// If number exceeds remaining target, no need to continue

further (sorted array)

if (candidates[i] > target) break;

// Choose current number

path.add(candidates[i]);

// Recurse with next index (can't reuse same element)

backtrack(i + 1, candidates, target - candidates[i], path,

result);
 // Backtrack: remove last added number

path.remove(path.size() - 1);

// Driver code

public static void main(String[] args) {

int[] candidates = {10, 1, 2, 7, 6, 1, 5};

int target = 8;

List<List<Integer>> combinations = combinationSum2(candidates,

target);

System.out.println("Unique Combinations that sum to target:");

for (List<Integer> comb : combinations) {

System.out.println(comb);

🔍 Dry Run Example

Input: candidates = [10,1,2,7,6,1,5], target = 8​
After sorting → [1,1,2,5,6,7,10]

Step Path Remaining Target Action

Start [] 8 —

Choose 1 [1] 7 Recurse

Choose 1 (next) [1,1] 6 Recurse

Choose 6 [1,1,6] 0 ✅ Valid

Backtrack [1,1] — Remove
6

Skip 1 duplicate — — Continue

Choose 2 [1,2] 5 Recurse

Choose 5 [1,2,5] 0 ✅ Valid

Backtrack [1,2] — Remove
5

Choose 7 [1,7] 0 ✅ Valid

Backtrack [1] — Remove
7

Choose 2 [2] 6 Recurse

Choose 6 [2,6] 0 ✅ Valid

✅ Output: [[1,1,6],[1,2,5],[1,7],[2,6]]

📊 Complexity Analysis
Aspect Complexity Explanation

Time O(2ⁿ) In the worst case, explore all

subsets

Space O(n) Recursion depth and path storage

Sorting O(n log n) To handle duplicates efficiently

⚙️ Edge Cases
Input Output Reason

[1,1,1,1], [[1,1]] Only one unique combo

2

[2,5,2,1,2] [[1,2,2],[ Skip duplicates

, 5 5]]

[1,2,3], 0 [[]] Empty set valid when target=0

[], 7 [] No candidates

🧩 Key Takeaways
 ●​ Main difference from Combination Sum I:​

○​ Each number can be used once.​

○​ Must avoid duplicates.​

●​ Trick: Sort + skip duplicates during same recursion level.​

●​ Pattern: Classic subset-sum type backtracking problem.​

✅ Final Summary
Concept Description

Approach Backtracking + Skip duplicates

Time Complexity O(2ⁿ)

Space Complexity O(n)

Core Step Sort → Choose → Recurse →

Backtrack

Handles ✅ Yes
Duplicates?

Excellent🔥 ​
Let’s continue with the Backtracking section — next up:

🧩 Problem 56: Permutations (Overall Count: 56 / 150)

📝 Problem Statement
Given an array nums of distinct integers, return all possible permutations of the
numbers.

You can return the answer in any order.

🔹 Example 1
Input: nums = [1,2,3]

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

🔹 Example 2
Input: nums = [0,1]

Output: [[0,1],[1,0]]

🔹 Example 3
Input: nums = [1]

Output: [[1]]

💡 Intuition
In permutations, order matters —​
we must arrange all numbers in every possible order.

We use backtracking to explore all possible arrangements by:

1.​ Picking a number,​

2.​ Marking it as “used,”​

3.​ Recursing with remaining unused numbers,​

4.​ Then unmarking (backtracking) to explore other paths.​

🧠 Approach
1.​ Maintain:​

○​ path → current permutation being formed.​

○​ used[] → boolean array marking whether a number is already chosen.​

○​ result → stores all valid permutations.​

2.​ Base case:​

○​ When path.size() == nums.length, add a copy of path to result.​

3.​ Otherwise:​

○​ Iterate over all indices.​

○​ Skip numbers already marked as used.​

○​ Choose a number, mark it, recurse.​

○​ After recursion, unmark and remove it (backtrack).​

💻 Java Code (With Detailed Comments)

import java.util.*;

public class Permutations {

public static List<List<Integer>> permute(int[] nums) {

List<List<Integer>> result = new ArrayList<>();

boolean[] used = new boolean[nums.length]; // track used elements

backtrack(nums, new ArrayList<>(), used, result);

return result;
 }

// Backtracking helper function

private static void backtrack(int[] nums, List<Integer> path,

boolean[] used, List<List<Integer>> result)

{

// 1️⃣ Base case: permutation complete

if (path.size() == nums.length) {

result.add(new ArrayList<>(path));

return;

// 2️⃣ Try every number

for (int i = 0; i < nums.length; i++) {

// Skip numbers already used in this path

if (used[i]) continue;

// Choose current number

path.add(nums[i]);

used[i] = true;

// Recurse to build the next position

backtrack(nums, path, used, result);

// Undo the choice (backtrack)

used[i] = false;
 path.remove(path.size() - 1);

// Driver code

public static void main(String[] args) {

int[] nums = {1, 2, 3};

List<List<Integer>> permutations = permute(nums);

System.out.println("All Permutations:");

for (List<Integer> p : permutations) {

System.out.println(p);

🔍 Dry Run Example

Input: nums = [1, 2, 3]

Step Path Used[] Action

Start [] [F,F,F] —

Pick 1 [1] [T,F,F] Recurse

Pick 2 [1,2] [T,T,F] Recurse

 Pick 3 [1,2,3] [T,T,T] ✅ Add result
Backtrack [1,2] [T,T,F] Remove 3

Pick 3 (earlier) [1,3] [T,F,T] Recurse

Pick 2 [1,3,2] [T,T,T] ✅ Add result

Backtrack all [] [F,F,F] Continue

Pick 2 first [2] [F,T,F] … continues …

✅ Final Result:​
[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

📊 Complexity Analysis
Aspect Complexity Explanation

Time O(n × n!) There are n! permutations, and copying each takes
O(n)

Space O(n) For recursion stack and used array

Output O(n × n!) Total number of permutations

Space

⚙️ Edge Cases
 Input Output Notes

[1] [[1]] Only one permutation

[0,1 [[0,1],[1, Two permutations

] 0]]

[] [[]] Empty permutation

🧩 Key Takeaways
●​ Pattern: Backtracking​

●​ Difference from Subsets: Order matters; use all elements exactly once​

●​ Key Step: Mark element as used, then unmark (backtrack)​

●​ Result Size: n! for array of size n​

✅ Final Summary
Concept Description

Approach Backtracking with “used” array

Time Complexity O(n × n!)

Space O(n)
Complexity
 Core Step Choose → Recurse →
Backtrack

When to Use When order of elements matters

Awesome 😎​
Let’s move forward to the next one in the Backtracking section — this one is a smart twist
on the subsets problem.

🧩 Problem 57: Subsets II (Overall Count: 57 / 150)

📝 Problem Statement
Given an integer array nums that may contain duplicates, return all possible subsets (the
power set).

The solution set must not contain duplicate subsets, and the subsets can be returned in
any order.

🔹 Example 1
Input: nums = [1,2,2]
Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]

🔹 Example 2
Input: nums = [0]
Output: [[],[0]]

💡 Intuition
This problem is almost identical to Subsets (Problem 53),​
except that the array can have duplicate elements.

To avoid duplicate subsets:

 1.​ We sort the array so that duplicates are adjacent.​

2.​ While backtracking, skip duplicates during the same recursive level.​

This ensures we only generate unique subsets.

🧠 Approach
1.​ Sort the array to make duplicate detection easy.​

2.​ Use backtracking as before:​

○​ Add current path to result.​

○​ Iterate over all choices starting from start.​

○​ If the current number equals the previous number and i > start, skip it
(duplicate on same level).​

○​ Add the number to path, recurse with i + 1.​

○​ Backtrack (remove last added number).​

💻 Java Code (With Detailed Comments)

import java.util.*;

public class SubsetsII {

public static List<List<Integer>> subsetsWithDup(int[] nums) {

List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums); // Sort to group duplicates
backtrack(0, nums, new ArrayList<>(), result);
return result;
}

// Backtracking helper
private static void backtrack(int start, int[] nums,
List<Integer> path, List<List<Integer>>
result) {
// 1️⃣ Add current subset (path) to result
result.add(new ArrayList<>(path));
 // 2️⃣ Explore all elements starting from 'start'
for (int i = start; i < nums.length; i++) {
// Skip duplicates: if same as previous on same recursion level
if (i > start && nums[i] == nums[i - 1]) continue;

// Choose current number

path.add(nums[i]);

// Recurse for next index

backtrack(i + 1, nums, path, result);

// Undo the choice (backtrack)

path.remove(path.size() - 1);
}
}

// Driver code
public static void main(String[] args) {
int[] nums = {1, 2, 2};
List<List<Integer>> subsets = subsetsWithDup(nums);

System.out.println("Unique Subsets:");
for (List<Integer> subset : subsets) {
System.out.println(subset);
}
}
}

🔍 Dry Run Example

Input: nums = [1,2,2]​
Sorted → [1,2,2]

Step Path Action Result So Far

Start [] Add to [[]]

result

Choose 1 [1] Recurse [[], [1]]

Choose 2 [1,2] Recurse [[], [1], [1,2]]

 Choose 2 again [1,2,2] ✅ Add [[], [1], [1,2],
[1,2,2]]

Backtrack [1,2] → Remove —

[1] last

Skip duplicate 2 — Continue —

Choose 2 (first occurrence at [2] ✅ Add [[], [1], [1,2],

root level) [1,2,2], [2]]

Choose 2 again [2,2] ✅ Add [[], [1], [1,2],

[1,2,2], [2], [2,2]]

✅ Final Result:​
[[], [1], [1,2], [1,2,2], [2], [2,2]]

📊 Complexity Analysis
Aspect Complexity Explanation

Time O(2ⁿ) Generate all possible

subsets

Space O(n) Recursion stack + path

Output O(2ⁿ) Number of subsets in result

Space

⚙️ Edge Cases
Input Output Reason

[1,2, [[],[1],[1,2],[1,2,2],[2], Avoid duplicates

2] [2,2]]

[1,1, [[],[1],[1,1],[1,1,1]] Only unique

1] subsets

[] [[]] Empty subset

[0] [[],[0]] Single element

🧩 Key Takeaways
 ●​ Pattern: Subset generation with duplicate handling.​

●​ Key trick: if (i > start && nums[i] == nums[i - 1]) continue;​

●​ Why it works: Prevents duplicate elements at the same recursive level.​

●​ Sorted array ensures duplicates are adjacent for easy skipping.​

✅ Final Summary
Concept Description

Approach Backtracking with duplicate skip

Time Complexity O(2ⁿ)

Space Complexity O(n)

Core Step Sort → Skip duplicates →

Recurse

Handles ✅ Yes
duplicates?

Perfect💪 ​
Now we’re entering one of the most classic and important backtracking problems —
searching words in a 2D grid.

🧩 Problem 58: Word Search (Overall Count: 58 / 150)

📝 Problem Statement
Given an m x n grid of characters board and a string word, return true if word exists in
the grid.

The word can be constructed from letters of sequentially adjacent cells,​

where adjacent cells are horizontally or vertically neighboring.​
The same letter cell may not be used more than once.
🔹 Example 1
Input:
board = [
['A','B','C','E'],
['S','F','C','S'],
['A','D','E','E']
]
word = "ABCCED"

Output: true

🔹 Example 2
Input:
board = [
['A','B','C','E'],
['S','F','C','S'],
['A','D','E','E']
]
word = "SEE"

Output: true

🔹 Example 3
Input:
board = [
['A','B','C','E'],
['S','F','C','S'],
['A','D','E','E']
]
word = "ABCB"

Output: false

💡 Intuition
We need to check whether we can trace the given word in the grid using valid moves (up,
down, left, right) without reusing any cell.

This is a depth-first search (DFS) with backtracking problem:

1.​ For each cell in the grid:​

 ○​ If it matches the first letter of the word, start DFS from it.​

2.​ DFS recursively explores all four directions:​

○​ If a character doesn’t match → stop that path.​

○​ If we reach the end of the word → success!​

3.​ Mark cells as visited temporarily to avoid reuse.​

4.​ Backtrack by unmarking cells after recursion.​

🧠 Approach
1.​ Traverse every cell in the grid.​

2.​ For each cell (i, j):​

○​ If board[i][j] == word[0], start DFS.​

3.​ DFS function parameters:​

○​ index: position in word currently being matched​

○​ If index == word.length(), return true (word found)​

○​ If cell out of bounds or mismatch → return false​

4.​ Temporarily mark cell as visited (e.g., set to '#').​

5.​ Explore all 4 directions recursively.​

6.​ Restore cell (backtrack).​

💻 Java Code (With Detailed Comments)

public class WordSearch {

public static boolean exist(char[][] board, String word) {

int rows = board.length;
int cols = board[0].length;
 // Try starting DFS from every cell
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
// Start DFS if first character matches
if (board[i][j] == word.charAt(0) && dfs(board, word, i, j,
0)) {
return true;
}
}
}
return false; // Word not found
}

// DFS helper method

private static boolean dfs(char[][] board, String word, int row, int col,
int index) {
// 1️⃣ If we've matched the entire word
if (index == word.length()) {
return true;
}

// 2️⃣ Boundary checks and character match

if (row < 0 || row >= board.length || col < 0 || col >=
board[0].length
|| board[row][col] != word.charAt(index)) {
return false;
}

// 3️⃣ Mark the cell as visited

char temp = board[row][col];
board[row][col] = '#';

// 4️⃣ Explore in all 4 directions (up, down, left, right)

boolean found = dfs(board, word, row + 1, col, index + 1) ||
dfs(board, word, row - 1, col, index + 1) ||
dfs(board, word, row, col + 1, index + 1) ||
dfs(board, word, row, col - 1, index + 1);

// 5️⃣ Backtrack: restore the cell

board[row][col] = temp;

return found;
}

// Driver code
 public static void main(String[] args) {
char[][] board = {
{'A', 'B', 'C', 'E'},
{'S', 'F', 'C', 'S'},
{'A', 'D', 'E', 'E'}
};
String word = "ABCCED";

System.out.println("Word Found? " + exist(board, word));

}
}

🔍 Dry Run Example

Input:

board = [
['A','B','C','E'],
['S','F','C','S'],
['A','D','E','E']
]
word = "ABCCED"

Step Cell Word Index Action State

(0,0) 'A' 0 Match 'A' Mark visited

(0,1) 'B' 1 Match 'B' Mark visited

(0,2) 'C' 2 Match 'C' Mark visited

(1,2) 'C' 3 Match 'C' Mark visited

(2,2) 'E' 4 Match 'E' Mark visited

(2,1) 'D' 5 Match 'D' ✅ Word found

✅ Returns true.

📊 Complexity Analysis
Aspect Complexity Explanation
Time O(m × n × For each cell, we explore up to 4 directions for L = length
4ᴸ) of word

Space O(L) Recursion depth for the word length

In-place O(1) No extra visited array (in-place marking)

space

⚙️ Edge Cases
Case Example Output

Single cell board = [['A']], word = "A" ✅ true

Word longer than total cells board = [['A','B']], word = ❌ false
"ABC"`

Duplicates in board Handled correctly

Empty board returns false

🧩 Key Takeaways
●​ Backtracking on a grid → explore all possible paths.​

●​ Mark visited to prevent revisiting the same cell.​

●​ Restore after recursion (backtrack).​

●​ This is a DFS pattern combined with in-place modification.​

✅ Final Summary
Concept Description

Approach DFS + Backtracking

Time Complexity O(m × n × 4ᴸ)

Space O(L)
Complexity

Key Step Mark → Explore → Restore

 Pattern Matrix-based backtracking
search

Perfect 😎
Let’s move on to the next problem in the Backtracking section — one of the most elegant
recursive problems that combines string manipulation and backtracking.

🧩 Problem 59: Palindrome Partitioning (Overall Count:

59 / 150)

📝 Problem Statement
Given a string s, partition s such that every substring of the partition is a palindrome.​
Return all possible palindrome partitioning of s.

🔹 Example 1
Input: s = "aab"
Output: [["a","a","b"],["aa","b"]]

🔹 Example 2
Input: s = "a"
Output: [["a"]]

💡 Intuition
We need to break the string into parts such that each part is a palindrome.

For example, in "aab":

●​ We can split as "a" + "a" + "b" (all palindromes)​

●​ Or "aa" + "b" (also all palindromes)​

To explore all valid ways:

1.​ We check every possible prefix of the string.​

2.​ If the prefix is a palindrome, we recursively solve the rest of the string.​

3.​ Backtrack when we reach the end.​

🧠 Approach
1.​ Start from index 0.​

2.​ Try to cut the string at every position i.​

3.​ If substring s[start...i] is palindrome:​

○​ Add it to the current partition.​

○​ Recurse for i+1.​

4.​ If we reach the end of the string → add current partition to result.​

5.​ Backtrack by removing the last substring.​

💻 Java Code (With Detailed Comments)

import java.util.*;

public class PalindromePartitioning {

public static List<List<String>> partition(String s) {

List<List<String>> result = new ArrayList<>();
backtrack(0, s, new ArrayList<>(), result);
return result;
}

// Backtracking helper function

private static void backtrack(int start, String s,
List<String> path, List<List<String>>
result) {
// 1️⃣ Base case: if we reach end of string
 if (start == s.length()) {
result.add(new ArrayList<>(path)); // Add current partition
return;
}

// 2️⃣ Try all possible end indices

for (int end = start; end < s.length(); end++) {
// If substring s[start...end] is a palindrome
if (isPalindrome(s, start, end)) {
// Choose the substring
path.add(s.substring(start, end + 1));

// Explore further partitions

backtrack(end + 1, s, path, result);

// Undo the choice (backtrack)

path.remove(path.size() - 1);
}
}
}

// Utility: check if substring s[l...r] is palindrome

private static boolean isPalindrome(String s, int l, int r) {
while (l < r) {
if (s.charAt(l) != s.charAt(r)) return false;
l++;
r--;
}
return true;
}

// Driver code
public static void main(String[] args) {
String s = "aab";
List<List<String>> partitions = partition(s);

System.out.println("All Palindrome Partitions:");

for (List<String> p : partitions) {
System.out.println(p);
}
}
}
🔍 Dry Run Example
Input: "aab"

Step Index Path Action

0 0 [] Start
recursion

0–0 "a" palindrome Add "a" → recurse

1 1 ["a"] Continue

1–1 "a" palindrome Add "a" → recurse

2 2 ["a", "a"] Continue

2–2 "b" palindrome Add "b" → ✅ Add to result

Backtrack Remove last ["a", "a"] → ["a"]

1–2 "ab" not palindrome Skip

Backtrack Remove last ["a"] → []

0–1 "aa" palindrome Add "aa" → recurse

2 2 ["aa"] Continue

2–2 "b" palindrome Add "b" → ✅ Add to result

Done — [["a","a","b"], ["aa","b"]]

✅ Final Output:
[["a","a","b"],["aa","b"]]

📊 Complexity Analysis
Aspect Complexit Explanation
y

Time O(n × 2ⁿ) Each character can be a cut or not; palindrome check adds
O(n)

Space O(n) For recursion + path storage

 Output O(2ⁿ) For storing all partitions
space

⚙️ Edge Cases
Input Output Reason

"a" [["a"]] Single character

"aaa [["a","a","a"],["a","aa"],["aa","a"] Multiple partitions

" ,["aaa"]]

"" [[]] Empty string

🧩 Key Takeaways
●​ Backtracking pattern — choose, explore, un-choose.​

●​ Palindrome check at each step.​

●​ No duplicates, since partitions are based on index positions.​

✅ Final Summary
Concept Description

Approach DFS + Backtracking

Time Complexity O(n × 2ⁿ)

Space O(n)
Complexity

Core Idea Try all cuts, check palindrome, backtrack

Pattern String partition + recursion

Great 😎 ​
Let’s continue with the next Backtracking problem — mapping digits to letters like a phone
keypad.
🧩 Problem 60: Letter Combinations of a Phone
Number (Overall Count: 60 / 150)

📝 Problem Statement
Given a string containing digits from '2' to '9', return all possible letter combinations
that the number could represent.​
The mapping of digits to letters is the same as on a telephone keypad:

2 → "abc", 3 → "def", 4 → "ghi", 5 → "jkl", 6 → "mno",

7 → "pqrs", 8 → "tuv", 9 → "wxyz"

Return the answer in any order.

🔹 Example 1
Input: digits = "23"
Output: ["ad","ae","af","bd","be","bf","cd","ce","cf"]

🔹 Example 2
Input: digits = ""
Output: []

🔹 Example 3
Input: digits = "2"
Output: ["a","b","c"]

💡 Intuition
This is a classic combinatorial problem — for each digit, choose a letter, and continue
building the string recursively.

We can solve this using backtracking:

1.​ For the current digit, iterate over all letters it maps to.​

2.​ Add one letter to the current combination.​

 3.​ Recurse for the next digit.​

4.​ When the combination length equals the digits length → add to result.​

5.​ Backtrack by removing the last letter.​

🧠 Approach
1.​ Use a Map<Character, String> for the digit-to-letter mapping.​

2.​ Initialize an empty path (StringBuilder or List of characters).​

3.​ Start recursive backtracking from index 0.​

4.​ At each recursive step:​

○​ If path.length() == digits.length(), add combination to result.​

○​ Otherwise, for the current digit, iterate over its letters:​

■​ Append letter to path.​

■​ Recurse for next index.​

■​ Remove last letter (backtrack).​

💻 Java Code (With Detailed Comments)

import java.util.*;

public class LetterCombinationsPhoneNumber {

public static List<String> letterCombinations(String digits) {

List<String> result = new ArrayList<>();
if (digits == null || digits.length() == 0) return result;

// Mapping of digits to letters

String[] mapping = {
"", // 0
"", // 1
"abc", // 2
 "def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz" // 9
};

backtrack(digits, 0, new StringBuilder(), result, mapping);

return result;
}

// Backtracking helper function

private static void backtrack(String digits, int index, StringBuilder
path,
List<String> result, String[] mapping) {
// 1️⃣ Base case: combination complete
if (index == digits.length()) {
result.add(path.toString());
return;
}

// 2️⃣ Get letters mapped to current digit

char digit = digits.charAt(index);
String letters = mapping[digit - '0'];

// 3️⃣ Explore all letters

for (char c : letters.toCharArray()) {
path.append(c); // Choose
backtrack(digits, index + 1, path, result, mapping); // Recurse
path.deleteCharAt(path.length() - 1); // Backtrack
}
}

// Driver code
public static void main(String[] args) {
String digits = "23";
List<String> combinations = letterCombinations(digits);

System.out.println("Letter combinations:");
for (String combo : combinations) {
System.out.println(combo);
}
}
}

🔍 Dry Run Example

Input: "23" → mapping:

●​ '2' → "abc"​

●​ '3' → "def"​

Step Path Index Action

0 "" 0 Start recursion

0 "a" 1 Add 'a' for digit 2

1 "ad" 2 Add 'd' for digit 3 → ✅ Add to result

1 "ae" 2 Add 'e' → ✅ Add to result
1 "af" 2 Add 'f' → ✅ Add to result

Backtrack "a" 1 Remove last, try next letter for digit 2

0 "b" 1 … repeat …

0 "c" 1 … repeat …

✅ Output:
["ad","ae","af","bd","be","bf","cd","ce","cf"]

📊 Complexity Analysis
Aspect Complexity Explanation

Time O(4ⁿ) Maximum 4 letters per digit, n = digits.length()

Space O(n) Recursion stack + path

Output O(4ⁿ) Total number of combinations

space

⚙️ Edge Cases
 Input Output Notes

"" [] Empty input → no combinations

"2" ["a","b","c"] Single digit

"79" All combinations from 4 × 4 letters Correctly handles digits with 4 letters

🧩 Key Takeaways
●​ Pattern: DFS / backtracking for combinatorial generation.​

●​ Key trick: Use StringBuilder and backtrack after recursion.​

●​ Mapping array simplifies letter lookup.​

●​ Output size depends exponentially on number of digits.​

✅ Final Summary
Concept Description

Approach Backtracking + digit mapping

Time Complexity O(4ⁿ)

Space O(n)
Complexity

Core Step Choose letter → Recurse →

Backtrack

Pattern Combinatorial generation

Awesome 😎​
Next up in Backtracking is the classic N-Queens problem.

🧩 Problem 61: N Queens (Overall Count: 61 / 150)

📝 Problem Statement
The N-Queens problem asks: place n queens on an n × n chessboard such that no two
queens attack each other.​
Return all distinct solutions. Each solution contains the board configuration, with 'Q' for a
queen and '.' for an empty space.

🔹 Example 1
Input: n = 4
Output:
[
[".Q..",
"...Q",
"Q...",
"..Q."],

["..Q.",
"Q...",
"...Q",
".Q.."]
]

🔹 Example 2
Input: n = 1
Output: [["Q"]]

💡 Intuition
We need to place queens row by row, making sure each new queen is not attacked by
previously placed queens.

Constraints for placing a queen at (row, col):

1.​ No queen in the same column.​

2.​ No queen in the same diagonal (row - col or row + col).​

Use backtracking to:

1.​ Try each column in the current row.​

 2.​ If safe, place a queen and recurse for next row.​

3.​ Remove queen (backtrack) and try next column.​

🧠 Approach
1.​ Use arrays/sets to track:​

○​ cols → columns with queens​

○​ diag1 → diagonals from top-left to bottom-right (row - col)​

○​ diag2 → diagonals from top-right to bottom-left (row + col)​

2.​ Recursively place queens row by row.​

3.​ When row == n, all queens are placed → add current board to results.​

4.​ Backtrack after each attempt.​

💻 Java Code (With Detailed Comments)

import java.util.*;
public class NQueens {

public static List<List<String>> solveNQueens(int n) {

List<List<String>> result = new ArrayList<>();
char[][] board = new char[n][n];

// Initialize board with '.'

for (int i = 0; i < n; i++) {
Arrays.fill(board[i], '.');
}

// Sets to track columns and diagonals

Set<Integer> cols = new HashSet<>();
Set<Integer> diag1 = new HashSet<>(); // row - col
Set<Integer> diag2 = new HashSet<>(); // row + col

backtrack(0, n, board, cols, diag1, diag2, result);

return result;
 }

// Backtracking helper function

private static void backtrack(int row, int n, char[][] board,
Set<Integer> cols, Set<Integer> diag1,
Set<Integer> diag2,
List<List<String>> result) {
// 1️⃣ All queens placed
if (row == n) {
result.add(constructBoard(board));
return;
}

// 2️⃣ Try placing queen in each column

for (int col = 0; col < n; col++) {
if (cols.contains(col) || diag1.contains(row - col) ||
diag2.contains(row + col)) {
continue; // Unsafe, skip
}

// 3️⃣ Place queen

board[row][col] = 'Q';
cols.add(col);
diag1.add(row - col);
diag2.add(row + col);

// 4️⃣ Recurse for next row

backtrack(row + 1, n, board, cols, diag1, diag2, result);

// 5️⃣ Backtrack: remove queen

board[row][col] = '.';
cols.remove(col);
diag1.remove(row - col);
diag2.remove(row + col);
}
}

// Convert board to list of strings

private static List<String> constructBoard(char[][] board) {
List<String> res = new ArrayList<>();
for (char[] row : board) {
res.add(new String(row));
}
return res;
}
 // Driver code
public static void main(String[] args) {
int n = 4;
List<List<String>> solutions = solveNQueens(n);

System.out.println("All solutions for " + n + "-Queens:");

for (List<String> sol : solutions) {
for (String row : sol) {
System.out.println(row);
}
System.out.println();
}
}
}

🔍 Dry Run Example

Input: n = 4

Row Col Choices Action

0 0–3 Try placing Q at each col

0,1 0–3 Only col 1 valid

1 0–3 Check safety using cols &

diagonals

2–3 Continue recursively Backtrack if no safe col

Resul [[".Q..","...Q","Q...","..Q."],
t ["..Q.","Q...","...Q",".Q.."]]

✅ Two valid solutions found.

📊 Complexity Analysis
Aspect Complexity Explanation

Time O(N!) Place N queens row by row; pruning reduces

possibilities

Space O(N²) Board + recursion stack

 Auxiliary Space O(N) Sets to track columns & diagonals

⚙️ Edge Cases
Input Output

n = 1 [["Q"]]

n = 2 or [] (no solution)
3

n = 8 92 solutions (classic
8-Queens)

🧩 Key Takeaways
●​ Pattern: Backtracking with constraints.​

●​ Optimization: Track columns & diagonals to avoid scanning entire board.​

●​ Core idea: Place queen row by row, check constraints, recurse, backtrack.​

GREEDY

🧩 Problem 63: Maximum Subarray (Overall Count: 63 /

150)

📝 Problem Statement
Given an integer array nums, find the contiguous subarray (containing at least one
number) which has the largest sum and return its sum.

🔹 Example 1
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

🔹 Example 2
Input: nums = [1]
Output: 1

💡 Intuition
●​ At each step, we decide whether to extend the previous subarray or start a new
subarray at current element.​

●​ This is a classic greedy + dynamic programming problem.​

Locally, the best choice is:​

​
current_sum = max(nums[i], nums[i] + current_sum)

●​

🧠 Approach (Kadane’s Algorithm)

1.​ Initialize:​

○​ maxSum = nums[0] → stores global maximum.​

○​ currentSum = nums[0] → stores maximum ending at current position.​

2.​ Iterate from i = 1 to nums.length - 1:​

○​ Update currentSum = max(nums[i], nums[i] + currentSum)​

○​ Update maxSum = max(maxSum, currentSum)​

3.​ Return maxSum.​

💻 Java Code (With Detailed Comments)

public class MaximumSubarray {

public static int maxSubArray(int[] nums) {

// Initialize current sum and max sum with first element
int currentSum = nums[0];
int maxSum = nums[0];

// Iterate over array starting from second element

for (int i = 1; i < nums.length; i++) {
// Decide: extend previous subarray or start new subarray
currentSum = Math.max(nums[i], nums[i] + currentSum);

// Update global maximum

maxSum = Math.max(maxSum, currentSum);
}

return maxSum;
}

// Driver code
public static void main(String[] args) {
int[] nums = {-2,1,-3,4,-1,2,1,-5,4};
System.out.println("Maximum Subarray Sum: " + maxSubArray(nums));
}
}

🔍 Dry Run Example

Input: [-2,1,-3,4,-1,2,1,-5,4]

i nums[i] currentSum maxSum Action

0 -2 -2 -2 Initialize

1 1 max(1,1+(-2))=1 max(-2,1)=1 Start new

subarray

2 -3 max(-3,1+(-3))=-2 max(1,-2)=1 Extend subarray

3 4 max(4,-2+4)=4 max(1,4)=4 Start new

subarray

4 -1 max(-1,4+(-1))=3 max(4,3)=4 Extend subarray

 5 2 max(2,3+2)=5 max(4,5)=5 Extend subarray

6 1 max(1,5+1)=6 max(5,6)=6 Extend subarray

7 -5 max(-5,6+(-5))=1 max(6,1)=6 Extend subarray

8 4 max(4,1+4)=5 max(6,5)=6 Extend subarray

✅ Final Output: 6

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass through

array

Space O(1) Only two variables used

⚙️ Edge Cases
Input Output

[1] 1

[-1,-2,-3 -1
]

[5,4,-1,7 23
,8]

🧩 Key Takeaways
●​ Greedy Choice: At each index, decide to extend previous subarray or start new.​

●​ Pattern: Kadane’s algorithm.​

●​ Extremely efficient: O(n) time, O(1) space.​

Perfect 😎​
Let’s continue with the next Greedy problem.
🧩 Problem 64: Jump Game (Overall Count: 64 / 150)
📝 Problem Statement
You are given an array of non-negative integers nums where each element represents your
maximum jump length at that position.

Return true if you can reach the last index, otherwise return false.

🔹 Example 1
Input: nums = [2,3,1,1,4]

Output: true

Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

🔹 Example 2
Input: nums = [3,2,1,0,4]

Output: false

Explanation: You will always reach index 3, but nums[3] = 0, so cannot move further.

💡 Intuition
●​ At each index, you can jump up to nums[i] steps.​

●​ Track the farthest reachable index as you iterate.​

●​ If at any point your current index > farthest reachable, return false.​

●​ If you can reach or go beyond the last index, return true.​

This is a classic Greedy approach: always keep track of the farthest reachable point.

🧠 Approach
1.​ Initialize maxReach = 0.​

2.​ Iterate over array indices i = 0 to nums.length - 1:​

○​ If i > maxReach, cannot reach current index → return false.​

○​ Update maxReach = max(maxReach, i + nums[i]).​

3.​ If iteration completes, return true (last index is reachable).​

💻 Java Code (With Comments)

public class JumpGame {

public static boolean canJump(int[] nums) {

int maxReach = 0;

for (int i = 0; i < nums.length; i++) {

// If current index is beyond the farthest reachable, cannot

proceed

if (i > maxReach) return false;

// Update the farthest reachable index

maxReach = Math.max(maxReach, i + nums[i]);

return true; // Last index is reachable

 }

// Driver code

public static void main(String[] args) {

int[] nums1 = {2,3,1,1,4};

int[] nums2 = {3,2,1,0,4};

System.out.println("Can jump (nums1)? " + canJump(nums1)); // true

System.out.println("Can jump (nums2)? " + canJump(nums2)); // false

🔍 Dry Run Example

Input: [2,3,1,1,4]

i nums[i] maxReac Action

h

0 2 2 Can reach index 2

1 3 4 Update maxReach =
max(2,1+3)=4

2 1 4 maxReach unchanged

3 1 4 maxReach unchanged
4 4 8 Last index reachable → return true

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass through

array

Space O(1) Only variable maxReach

⚙️ Edge Cases
Input Output Reason

[0] true Already at last index

[0,1] false Cannot move from

start

[2,0, true Can jump over zeros

0]

🧩 Key Takeaways
●​ Greedy approach tracks farthest reachable index.​
 ●​ At each step, decide locally optimal move: extend reach as far as possible.​

●​ Extremely efficient: O(n) time, O(1) space.​

Perfect😎 ​
Let’s move to the next Greedy problem.

🧩 Problem 65: Jump Game II (Overall Count: 65 / 150)

📝 Problem Statement
You are given an array of non-negative integers nums where each element represents your
maximum jump length at that position.

Return the minimum number of jumps to reach the last index. You can assume that you
can always reach the last index.

🔹 Example 1
Input: nums = [2,3,1,1,4]

Output: 2

Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

🔹 Example 2
Input: nums = [2,3,0,1,4]

Output: 2

💡 Intuition
 ●​ We need minimum jumps to reach the end.​

●​ Similar to Jump Game I, we track farthest reachable index.​

●​ Use a greedy layer-by-layer approach:​

1.​ At current step, track the farthest we can reach.​

2.​ When we reach the end of the current jump range, increment jumps.​

●​ This ensures minimum number of jumps.​

🧠 Approach
1.​ Initialize:​

○​ jumps = 0 → number of jumps made.​

○​ currentEnd = 0 → farthest reachable within current jump.​

○​ farthest = 0 → farthest reachable in next jump.​

2.​ Iterate through array up to second-last index:​

○​ Update farthest = max(farthest, i + nums[i]).​

○​ If i == currentEnd:​

■​ Increment jumps.​

■​ Set currentEnd = farthest.​

3.​ Return jumps.​

💻 Java Code (With Comments)

public class JumpGameII {

public static int jump(int[] nums) {

 int jumps = 0; // Number of jumps made

int currentEnd = 0; // End of current jump

int farthest = 0; // Farthest index reachable

for (int i = 0; i < nums.length - 1; i++) {

// Update farthest reachable index

farthest = Math.max(farthest, i + nums[i]);

// If reached the end of current jump, make a jump

if (i == currentEnd) {

jumps++;

currentEnd = farthest;

return jumps;

// Driver code

public static void main(String[] args) {

int[] nums1 = {2,3,1,1,4};

int[] nums2 = {2,3,0,1,4};

System.out.println("Minimum jumps (nums1): " + jump(nums1)); // 2

System.out.println("Minimum jumps (nums2): " + jump(nums2)); // 2

}
}

🔍 Dry Run Example

Input: [2,3,1,1,4]

i nums[i] farthest currentEnd jumps

0 2 2 0→2 1

1 3 4 2 1

2 1 4 2→4 2

3 1 4 4 2

4 4 — — 2

✅ Minimum jumps = 2

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass through array

Space O(1) Only variables jumps, currentEnd,

farthest
⚙️ Edge Cases
Input Output Reason

[0] 0 Already at last index

[1,2] 1 One jump to reach

end

[2,3,0,1, 2 Layered jumps

4]

🧩 Key Takeaways
●​ Greedy: Always jump to the farthest reachable point within the current jump.​

●​ Layered approach: Treat each range of indices as one jump.​

●​ Efficient solution: O(n) time, O(1) space.

🧩 Problem 66: Gas Station (Overall Count: 66 / 150)

📝 Problem Statement
There are n gas stations along a circular route.

●​ gas[i] is the amount of gas at station i.​

●​ cost[i] is the gas needed to travel from station i to the next station (i + 1) %
n.​
Return the starting gas station’s index if you can travel around the circuit once in the
clockwise direction, otherwise return -1.

You can assume there is exactly one solution if a solution exists.

🔹 Example 1
Input: gas = [1,2,3,4,5], cost = [3,4,5,1,2]

Output: 3

Explanation: Start at station 3 and travel around the circuit.

🔹 Example 2
Input: gas = [2,3,4], cost = [3,4,3]

Output: -1

💡 Intuition
●​ To complete the circuit, total gas ≥ total cost.​

●​ Locally, if at any station i, the tank goes negative, then cannot start from any
station before i + 1.​

●​ Greedy approach: track current tank while iterating, reset starting index when tank <
0.​

🧠 Approach
1.​ Initialize:​

○​ totalGas = 0 → total gas difference.​

○​ tank = 0 → current gas tank.​

 ○​ start = 0 → candidate starting index.​

2.​ Iterate i = 0 to n-1:​

○​ tank += gas[i] - cost[i]​

○​ totalGas += gas[i] - cost[i]​

○​ If tank < 0:​

■​ Cannot start from start, move start = i + 1​

■​ Reset tank = 0​

3.​ After iteration:​

○​ If totalGas >= 0 → return start​

○​ Else → return -1​

💻 Java Code (With Comments)

public class GasStation {

public static int canCompleteCircuit(int[] gas, int[] cost) {

int totalGas = 0; // Total net gas

int tank = 0; // Current tank

int start = 0; // Candidate starting index

for (int i = 0; i < gas.length; i++) {

int diff = gas[i] - cost[i];

tank += diff;

totalGas += diff;
 // If tank goes negative, cannot start from 'start'

if (tank < 0) {

start = i + 1; // Next station is new candidate

tank = 0; // Reset tank

return totalGas >= 0 ? start : -1;

// Driver code

public static void main(String[] args) {

int[] gas1 = {1,2,3,4,5};

int[] cost1 = {3,4,5,1,2};

int[] gas2 = {2,3,4};

int[] cost2 = {3,4,3};

System.out.println("Start index (Example 1): " +

canCompleteCircuit(gas1, cost1)); // 3

System.out.println("Start index (Example 2): " +

canCompleteCircuit(gas2, cost2)); // -1

🔍 Dry Run Example

Input: gas = [1,2,3,4,5], cost = [3,4,5,1,2]

i gas[i]-cost[i tank totalGas start

]

0 -2 -2 -2 1

1 -2 -2 -4 2

2 -2 -2 -6 3

3 3 3 -3 3

4 3 6 0 3

✅ totalGas ≥ 0 → return 3

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass through stations

Space O(1) Only variables for tank, totalGas, start

⚙️ Edge Cases
 Input Output Reason

[0], [0] 0 Single station, zero

gas/cost

[1,1,1], -1 Cannot complete

[1,2,1]

🧩 Key Takeaways
●​ Greedy choice: If tank < 0, next station must be new start.​

●​ Check total gas to ensure a solution exists.​

●​ Efficient: O(n) time, O(1) space.​

Perfect😎 ​
Let’s continue with the next Greedy problem.

🧩 Problem 67: Hand of Straights (Overall Count: 67 /

150)

📝 Problem Statement
Alice has a hand of cards given as an integer array hand and an integer groupSize.

●​ Task: Check if it is possible to rearrange the hand into groups of consecutive cards,
each of size groupSize.​

●​ Return true if possible, otherwise false.​

🔹 Example 1
Input: hand = [1,2,3,6,2,3,4,7,8], groupSize = 3

Output: true

Explanation: Rearrange as [1,2,3], [2,3,4], [6,7,8]

🔹 Example 2
Input: hand = [1,2,3,4,5], groupSize = 4

Output: false

💡 Intuition
●​ We need groups of consecutive numbers of length groupSize.​

●​ Greedy idea: always start forming a group from the smallest available card.​

●​ Use a TreeMap (sorted map) to track card counts.​

●​ Reduce count as we form consecutive groups.​

●​ If at any step, consecutive numbers are missing → return false.​

🧠 Approach
1.​ Count frequency of each card using TreeMap<Integer, Integer> (sorted keys).​

2.​ While map is not empty:​

○​ Pick smallest key as start.​

○​ Try to form a group of size groupSize starting from start.​

○​ For each number num in [start, start + groupSize - 1]:​

 ■​ If num not in map → return false​

■​ Decrease count of num. If count becomes 0 → remove key.​

3.​ If all cards are used → return true.​

💻 Java Code (With Comments)

import java.util.*;

public class HandOfStraights {

public static boolean isNStraightHand(int[] hand, int groupSize) {

if (hand.length % groupSize != 0) return false;

TreeMap<Integer, Integer> map = new TreeMap<>();

// Count frequency of each card

for (int card : hand) {

map.put(card, map.getOrDefault(card, 0) + 1);

// Form groups starting from smallest available card

while (!map.isEmpty()) {

int start = map.firstKey(); // Smallest card

for (int i = 0; i < groupSize; i++) {

int curr = start + i;

if (!map.containsKey(curr)) return false; // Missing card

map.put(curr, map.get(curr) - 1); // Use one card

 if (map.get(curr) == 0) map.remove(curr); // Remove if none
left

return true; // All cards grouped successfully

// Driver code

public static void main(String[] args) {

int[] hand1 = {1,2,3,6,2,3,4,7,8};

int groupSize1 = 3;

int[] hand2 = {1,2,3,4,5};

int groupSize2 = 4;

System.out.println("Can form groups? " + isNStraightHand(hand1,

groupSize1)); // true

System.out.println("Can form groups? " + isNStraightHand(hand2,

groupSize2)); // false

🔍 Dry Run Example

Input: hand = [1,2,3,6,2,3,4,7,8], groupSize = 3

1.​ Count frequencies: {1:1,2:2,3:2,4:1,6:1,7:1,8:1}​

 2.​ Smallest card = 1 → form group [1,2,3]​
Updated map: {2:1,3:1,4:1,6:1,7:1,8:1}​

3.​ Smallest card = 2 → form group [2,3,4]​

Updated map: {6:1,7:1,8:1}​

4.​ Smallest card = 6 → form group [6,7,8]​

Updated map: {} → all used ✅​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n log n) TreeMap insertion/removal operations

Space O(n) Frequency map

⚙️ Edge Cases
Input Output Reason

[1,2,3], groupSize=1 true Each card forms a group

[1,2,3,4], false Cannot form groups of size

groupSize=3 3

🧩 Key Takeaways
●​ Greedy: Always start forming group from smallest available card.​
 ●​ TreeMap ensures sorted access for smallest card.​

●​ Efficient solution for grouping consecutive numbers.​

Perfect 😎 ​
Let’s continue with the next Greedy problem.

🧩 Problem 68: Merge Triplets to Form Target Triplet

(Overall Count: 68 / 150)

📝 Problem Statement
You are given an array of triplets triplets[i] = [ai, bi, ci] and a target = [x,
y, z].

●​ You can choose any subset of the triplets and merge them into a single triplet:​

○​ merge(a,b) → [max(a1,b1), max(a2,b2), max(a3,b3)]​

●​ Task: Return true if it is possible to obtain the target triplet exactly by merging
some triplets, otherwise return false.​

🔹 Example 1
Input: triplets = [[2,5,3],[1,8,4],[1,7,5]], target = [2,7,5]

Output: true

Explanation: Merge triplets [2,5,3] and [1,7,5] → [2,7,5]

🔹 Example 2
Input: triplets = [[3,4,5],[4,5,6]], target = [3,2,5]

Output: false
💡 Intuition
●​ Each element in the target must come from a triplet that does not exceed that value
in any component.​

●​ We need at least one triplet for each of the target components.​

●​ Greedy idea: Keep track of whether we can cover target components individually
without exceeding them.​

🧠 Approach
1.​ Initialize three boolean flags: foundX, foundY, foundZ = false.​

2.​ Iterate through each triplet [a,b,c]:​

○​ Skip triplet if any element > target element (cannot contribute to target).​

○​ If a == target[0] → foundX = true​

○​ If b == target[1] → foundY = true​

○​ If c == target[2] → foundZ = true​

3.​ After iterating all triplets, return foundX && foundY && foundZ.​

💻 Java Code (With Comments)

public class MergeTripletsToTarget {

public static boolean mergeTriplets(int[][] triplets, int[] target) {

boolean foundX = false, foundY = false, foundZ = false;

 for (int[] triplet : triplets) {

// Skip triplet if it exceeds target in any component

if (triplet[0] > target[0] || triplet[1] > target[1] ||

triplet[2] > target[2])

continue;

// Check if this triplet can contribute to target

if (triplet[0] == target[0]) foundX = true;

if (triplet[1] == target[1]) foundY = true;

if (triplet[2] == target[2]) foundZ = true;

// Return true if all components can be matched

return foundX && foundY && foundZ;

// Driver code

public static void main(String[] args) {

int[][] triplets1 = {{2,5,3},{1,8,4},{1,7,5}};

int[] target1 = {2,7,5};

int[][] triplets2 = {{3,4,5},{4,5,6}};

int[] target2 = {3,2,5};

System.out.println("Can form target (example1)? " +

mergeTriplets(triplets1, target1)); // true

System.out.println("Can form target (example2)? " +

mergeTriplets(triplets2, target2)); // false
 }

🔍 Dry Run Example

Input: triplets = [[2,5,3],[1,8,4],[1,7,5]], target = [2,7,5]

1.​ [2,5,3] → valid (≤ target)​

○​ a==2 → foundX = true​

○​ b==5 → not target[1] → skip​

○​ c==3 → not target[2] → skip​

2.​ [1,8,4] → b=8 > target[1]=7 → skip​

3.​ [1,7,5] → valid​

○​ a=1 → not target[0]​

○​ b=7 → foundY = true​

○​ c=5 → foundZ = true​

✅ All three flags true → return true

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Iterate through all triplets

Space O(1) Only three boolean flags

used
⚙️ Edge Cases
Input Output Reason

triplets with numbers > target false Cannot contribute

target already present in one triplet true Single triplet may suffice

target components spread across multiple true Merge greedily

triplets

🧩 Key Takeaways
●​ Greedy: Pick triplets that do not exceed target.​

●​ Track individually: Check if each target component can be matched.​

●​ Efficient solution: O(n) time, O(1) space.​

Perfect 😎 ​
Let’s continue with the next Greedy problem.

🧩 Problem 69: Partition Labels (Overall Count: 69 /

150)

📝 Problem Statement
You are given a string s.
 ●​ Partition the string into as many parts as possible so that each letter appears in at
most one part.​

●​ Return a list of integers representing the size of these parts.​

🔹 Example 1
Input: s = "ababcbacadefegdehijhklij"

Output: [9,7,8]

Explanation: The partition is "ababcbaca", "defegde", "hijhklij".

🔹 Example 2
Input: s = "eccbbbbdec"

Output: [10]

💡 Intuition
●​ For each character, track the last occurrence in the string.​

●​ Greedy idea: expand current partition to include all last occurrences of characters in
it.​

●​ When current index == end of partition, record size and start a new partition.​

🧠 Approach
1.​ Compute lastIndex[c] → last index of character c.​

2.​ Initialize:​

○​ start = 0 → start of current partition​

 ○​ end = 0 → end of current partition​

○​ result = [] → list of partition sizes​

3.​ Iterate over string:​

○​ Update end = max(end, lastIndex[s[i]])​

○​ If i == end:​

■​ Partition ends here → add end - start + 1 to result​

■​ Start new partition start = i + 1​

💻 Java Code (With Comments)

import java.util.*;

public class PartitionLabels {

public static List<Integer> partitionLabels(String s) {

List<Integer> result = new ArrayList<>();

int[] lastIndex = new int[26]; // Last index of each character

// Fill lastIndex array

for (int i = 0; i < s.length(); i++) {

lastIndex[s.charAt(i) - 'a'] = i;

int start = 0, end = 0;

 // Traverse string

for (int i = 0; i < s.length(); i++) {

end = Math.max(end, lastIndex[s.charAt(i) - 'a']); // Extend

partition

if (i == end) { // Partition end

result.add(end - start + 1);

start = i + 1; // Start new partition

return result;

// Driver code

public static void main(String[] args) {

String s1 = "ababcbacadefegdehijhklij";

String s2 = "eccbbbbdec";

System.out.println("Partition sizes (s1): " + partitionLabels(s1));

// [9,7,8]

System.out.println("Partition sizes (s2): " + partitionLabels(s2));

// [10]

🔍 Dry Run Example

Input: "ababcbacadefegdehijhklij"
 1.​ Last indices: a=8, b=5, c=7, d=14, e=15, f=11, g=13, h=19, i=22, j=23, k=20, l=21​

2.​ Traverse string, update end:​

○​ Index 0→8: a​

○​ Index 1→8: b​

○​ Index 8 == end → partition size = 9​

3.​ Next partition: start=9, end updated → 15 → partition size=7​

4.​ Next partition: start=16, end updated → 23 → partition size=8​

✅ Output: [9,7,8]

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass to fill lastIndex + traverse string

Space O(1) Array of size 26

⚙️ Edge Cases
Input Output Reason

"a" [1] Single character

"abc" [1,1,1] All characters unique

🧩 Key Takeaways
●​ Greedy: Extend partition until all last occurrences of characters are included.​

●​ Efficient: O(n) time, O(1) space using fixed-size array.​

●​ Pattern useful for interval merging or range coverage problems.​

Perfect 😎 ​
Let’s continue with the next Greedy problem.

🧩 Problem 70: Valid Parenthesis String (Overall Count:

70 / 150)

📝 Problem Statement
Given a string s containing only the characters '(', ')', and '*':

●​ '*' can be treated as '(', ')', or an empty string.​

●​ Return true if s can be made valid, otherwise return false.​

A valid string follows usual parenthesis rules.

🔹 Example 1
Input: s = "()"

Output: true

🔹 Example 2
Input: s = "(*)"

Output: true
🔹 Example 3
Input: s = "(*))"

Output: true

💡 Intuition
●​ Use a greedy range approach: track the possible number of open parentheses.​

●​ Maintain two counters:​

○​ low → minimum number of open '(' (treat '*' as ')')​

○​ high → maximum number of open '(' (treat '*' as '(')​

●​ After scanning:​

○​ low == 0 → string can be valid.​

🧠 Approach
1.​ Initialize low = 0, high = 0.​

2.​ Iterate over characters in s:​

○​ '(' → low++, high++​

○​ ')' → low--, high--​

○​ '*' → low-- (if >0), high++​

○​ If high < 0 → return false (too many ')')​

○​ Keep low = max(low,0) to avoid negative​

 3.​ After iteration, return low == 0.​

💻 Java Code (With Comments)

public class ValidParenthesisString {

public static boolean checkValidString(String s) {

int low = 0, high = 0;

for (char c : s.toCharArray()) {

if (c == '(') {

low++;

high++;

} else if (c == ')') {

low--;

high--;

} else { // '*' can be '(', ')' or empty

low--; // Treat '*' as ')'

high++; // Treat '*' as '('

// Low cannot be negative

if (high < 0) return false;

low = Math.max(low, 0);

}
 return low == 0;

// Driver code

public static void main(String[] args) {

String s1 = "()";

String s2 = "(*)";

String s3 = "(*))";

System.out.println(checkValidString(s1)); // true

System.out.println(checkValidString(s2)); // true

System.out.println(checkValidString(s3)); // true

🔍 Dry Run Example

Input: "(*))"

Char low high Action

'(' 1 1 Increment both

'*' 0 2 '*' can be '(' or ')'

')' -1→0 1 Decrement both, low≥0

')' -1→0 0 Decrement both, low≥0

✅ low == 0 → valid string

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass

Space O(1) Constant space for

counters

⚙️ Edge Cases
Input Output Reason

"" true Empty string is valid

"*" true Can treat as empty or '(' +

')'

")*(" false Cannot balance

🧩 Key Takeaways
●​ Greedy range: Track min/max possible open parentheses.​
 ●​ Efficient: O(n) time, O(1) space.​

●​ Works well with uncertain characters like '*' in parenthesis problems.​

INTERVALS

Perfect 😎
​
Now we move to the Intervals section in the Greedy topic.

🧩 Problem 71: Insert Interval (Overall Count: 71 / 150)

📝 Problem Statement
You are given a list of non-overlapping intervals intervals sorted by start times, and a
new interval newInterval = [start, end].

●​ Task: Insert newInterval into intervals and merge if necessary so that the list
remains non-overlapping and sorted.​

🔹 Example 1
Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]

🔹 Example 2
Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
Output: [[1,2],[3,10],[12,16]]

💡 Intuition
●​ Greedy approach: insert the new interval in order.​
 ●​ Merge overlapping intervals as we scan:​

○​ If interval ends before new interval → add to result.​

○​ If interval starts after new interval → add new interval, then remaining
intervals.​

○​ If overlap → merge intervals.​

🧠 Approach
1.​ Initialize result = [].​

2.​ Iterate over intervals:​

○​ If current interval ends < newInterval start → no overlap → add interval.​

○​ Else if current interval starts > newInterval end → no overlap → add

newInterval, then remaining intervals, break.​

Else → overlap → merge:​

​
newInterval[0] = min(newInterval[0], interval[0])
newInterval[1] = max(newInterval[1], interval[1])

○​
3.​ After iteration, if newInterval not added → add it.​

4.​ Return result.​

💻 Java Code (With Comments)

import java.util.*;

public class InsertInterval {

public static int[][] insert(int[][] intervals, int[] newInterval) {

List<int[]> result = new ArrayList<>();
int i = 0;
int n = intervals.length;
 // Add all intervals ending before newInterval starts
while (i < n && intervals[i][1] < newInterval[0]) {
result.add(intervals[i]);
i++;
}

// Merge all overlapping intervals with newInterval

while (i < n && intervals[i][0] <= newInterval[1]) {
newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
i++;
}

// Add merged newInterval

result.add(newInterval);

// Add remaining intervals

while (i < n) {
result.add(intervals[i]);
i++;
}

// Convert list to array

return result.toArray(new int[result.size()][]);
}

// Driver code
public static void main(String[] args) {
int[][] intervals1 = {{1,3},{6,9}};
int[] newInterval1 = {2,5};

int[][] intervals2 = {{1,2},{3,5},{6,7},{8,10},{12,16}};

int[] newInterval2 = {4,8};

System.out.println("Result 1: " +
Arrays.deepToString(insert(intervals1, newInterval1)));
System.out.println("Result 2: " +
Arrays.deepToString(insert(intervals2, newInterval2)));
}
}

🔍 Dry Run Example

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

1.​ Interval [1,3] overlaps with [2,5] → merge → [1,5]​

2.​ Interval [6,9] → after [1,5] → add [6,9]​

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

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass over

intervals

Space O(n) Result list storage

⚙️ Edge Cases
Input Output Reason

New interval before all Add at start No overlap

New interval after all Add at end No overlap

New interval covers all Merge into single Overlapping intervals

🧩 Key Takeaways
●​ Greedy: Merge overlapping intervals while scanning in order.​

●​ Pattern useful for interval insertion and merging problems.​

●​ Efficient solution: O(n) time, O(n) space.​

Perfect 😎 ​
Let’s continue with the next Intervals problem.
🧩 Problem 72: Merge Intervals (Overall Count: 72 /
150)

📝 Problem Statement
Given a collection of intervals intervals, merge all overlapping intervals and return an
array of the non-overlapping intervals that cover all the intervals in the input.

🔹 Example 1
Input: intervals = [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Intervals [1,3] and [2,6] overlap → merge to [1,6].

🔹 Example 2
Input: intervals = [[1,4],[4,5]]
Output: [[1,5]]

💡 Intuition
●​ Sort intervals by start time.​

●​ Iterate through intervals, merge overlapping intervals:​

○​ If current interval start ≤ last merged interval end → merge.​

○​ Else → add as new interval.​

Greedy approach ensures always merge consecutive overlapping intervals.

🧠 Approach
1.​ Sort intervals by start times.​

2.​ Initialize merged = [].​

3.​ Iterate over intervals:​

 ○​ If merged is empty or current start > last merged end → add interval.​

Else → merge:​
​
lastMerged[1] = max(lastMerged[1], current[1])

○​
4.​ Return merged.​

💻 Java Code (With Comments)

import java.util.*;

public class MergeIntervals {

public static int[][] merge(int[][] intervals) {

if (intervals.length <= 1) return intervals;

// Sort intervals by start time

Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));

List<int[]> merged = new ArrayList<>();

for (int[] interval : intervals) {

// If merged list empty or no overlap → add interval
if (merged.isEmpty() || merged.get(merged.size() - 1)[1] <
interval[0]) {
merged.add(interval);
} else {
// Overlapping → merge with last interval
merged.get(merged.size() - 1)[1] =
Math.max(merged.get(merged.size() - 1)[1], interval[1]);
}
}

return merged.toArray(new int[merged.size()][]);

}

// Driver code
public static void main(String[] args) {
int[][] intervals1 = {{1,3},{2,6},{8,10},{15,18}};
int[][] intervals2 = {{1,4},{4,5}};
 System.out.println("Merged 1: " +
Arrays.deepToString(merge(intervals1))); // [[1,6],[8,10],[15,18]]
System.out.println("Merged 2: " +
Arrays.deepToString(merge(intervals2))); // [[1,5]]
}
}

🔍 Dry Run Example

Input: [[1,3],[2,6],[8,10],[15,18]]

1.​ Sort: [[1,3],[2,6],[8,10],[15,18]]​

2.​ First interval [1,3] → add to merged​

3.​ [2,6] → overlaps [1,3] → merge → [1,6]​

4.​ [8,10] → no overlap → add​

5.​ [15,18] → no overlap → add​

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

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n log n) Sorting intervals

Space O(n) Result storage

⚙️ Edge Cases
Input Output Reason

Single interval Same Nothing to merge

Fully overlapping One interval Merge all

🧩 Key Takeaways
●​ Greedy: Merge overlapping intervals as we scan sorted intervals.​

●​ Sorting ensures local decisions lead to global correctness.​

●​ Pattern used in calendar merging, range coverage, interval scheduling.​

Perfect 😎 ​
Let’s continue with the next Intervals problem.

🧩 Problem 73: Non-Overlapping Intervals (Overall

Count: 73 / 150)

📝 Problem Statement
Given a collection of intervals intervals, find the minimum number of intervals you
need to remove to make the rest of the intervals non-overlapping.

🔹 Example 1
Input: intervals = [[1,2],[2,3],[3,4],[1,3]]

Output: 1

Explanation: Remove [1,3] to eliminate overlap.

🔹 Example 2
Input: intervals = [[1,2],[1,2],[1,2]]

Output: 2
💡 Intuition
●​ To maximize non-overlapping intervals, always pick the interval with the earliest
end time.​

●​ Greedy idea:​

○​ Sort intervals by end.​

○​ Keep track of end of last selected interval.​

○​ If next interval start < end → overlap → remove it (count++)​

🧠 Approach
1.​ Sort intervals by end time.​

2.​ Initialize:​

○​ count = 0 → number of removals​

○​ end = Integer.MIN_VALUE → end of last selected interval​

3.​ Iterate over intervals:​

○​ If interval[0] >= end → no overlap → update end = interval[1]​

○​ Else → overlap → count++ (remove this interval)​

4.​ Return count.​

💻 Java Code (With Comments)

import java.util.*;

public class NonOverlappingIntervals {

public static int eraseOverlapIntervals(int[][] intervals) {

if (intervals.length == 0) return 0;

// Sort intervals by end time

Arrays.sort(intervals, (a, b) -> Integer.compare(a[1], b[1]));

int count = 0;

int end = Integer.MIN_VALUE;

for (int[] interval : intervals) {

if (interval[0] >= end) {

// No overlap, select interval

end = interval[1];

} else {

// Overlap, remove interval

count++;

return count;

// Driver code

public static void main(String[] args) {

int[][] intervals1 = {{1,2},{2,3},{3,4},{1,3}};

int[][] intervals2 = {{1,2},{1,2},{1,2}};

 System.out.println("Removals needed (1): " +
eraseOverlapIntervals(intervals1)); // 1

System.out.println("Removals needed (2): " +

eraseOverlapIntervals(intervals2)); // 2

🔍 Dry Run Example

Input: [[1,2],[2,3],[3,4],[1,3]]

1.​ Sort by end: [[1,2],[1,3],[2,3],[3,4]]​

2.​ Interval [1,2] → end=2​

3.​ Interval [1,3] → start < 2 → overlap → remove → count=1​

4.​ Interval [2,3] → start ≥ 2 → select → end=3​

5.​ Interval [3,4] → start ≥ 3 → select → end=4​

✅ Total removals = 1

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n log n) Sorting intervals

Space O(1) Constant extra

space
⚙️ Edge Cases
Input Output Reason

Single interval 0 Nothing to remove

All overlapping n-1 Remove all except

one

🧩 Key Takeaways
●​ Greedy: Always pick interval with earliest end to maximize non-overlapping
intervals.​

●​ Efficient: O(n log n) time, O(1) space.​

●​ Pattern used in scheduling and interval selection problems.​

Perfect 😎 ​
Let’s continue with the next Intervals problem.

🧩 Problem 74: Meeting Rooms (Overall Count: 74 /

150)

📝 Problem Statement
Given an array of meeting time intervals intervals where intervals[i] = [starti,
endi], determine if a person could attend all meetings.

●​ Return true if no two meetings overlap, else return false.​

🔹 Example 1
Input: intervals = [[0,30],[5,10],[15,20]]

Output: false

Explanation: Meeting [0,30] overlaps with [5,10]

🔹 Example 2
Input: intervals = [[7,10],[2,4]]

Output: true

💡 Intuition
●​ If meetings overlap, cannot attend all.​

●​ Greedy approach:​

○​ Sort intervals by start time​

○​ Check if current start < previous end → overlap​

🧠 Approach
1.​ Sort intervals by start time.​

2.​ Iterate from second interval:​

○​ If interval[i][0] < interval[i-1][1] → overlap → return false​

3.​ If no overlaps found → return true​

💻 Java Code (With Comments)

import java.util.*;

public class MeetingRooms {

public static boolean canAttendMeetings(int[][] intervals) {

// Sort by start time

Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));

for (int i = 1; i < intervals.length; i++) {

// If current meeting starts before previous ends → overlap

if (intervals[i][0] < intervals[i - 1][1]) {

return false;

return true;

// Driver code

public static void main(String[] args) {

int[][] intervals1 = {{0,30},{5,10},{15,20}};

int[][] intervals2 = {{7,10},{2,4}};

System.out.println("Can attend all meetings (1)? " +

canAttendMeetings(intervals1)); // false

System.out.println("Can attend all meetings (2)? " +

canAttendMeetings(intervals2)); // true
 }

🔍 Dry Run Example

Input: [[0,30],[5,10],[15,20]]

1.​ Sort by start: [[0,30],[5,10],[15,20]]​

2.​ Check i=1: 5 < 30 → overlap → return false​

✅ Output: false

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n log n) Sorting intervals

Space O(1) Constant extra

space

⚙️ Edge Cases
Input Output Reason

Single meeting true No overlap

Meetings back-to-back true end == start allowed

🧩 Key Takeaways
●​ Greedy: Sort by start times, check consecutive intervals.​

●​ Efficient: O(n log n) time, O(1) space.​

●​ Useful for scheduling conflicts and interval management.​

Perfect 😎 ​
Let’s continue with the next Intervals problem.

🧩 Problem 75: Meeting Rooms II (Overall Count: 75 /

150)

📝 Problem Statement
Given an array of meeting time intervals intervals where intervals[i] = [starti,
endi], find the minimum number of conference rooms required.

🔹 Example 1
Input: intervals = [[0,30],[5,10],[15,20]]

Output: 2

🔹 Example 2
Input: intervals = [[7,10],[2,4]]

Output: 1
💡 Intuition
●​ At any point in time, number of ongoing meetings = rooms needed.​

●​ Use two arrays:​

○​ startTimes[] → sorted start times​

○​ endTimes[] → sorted end times​

●​ Greedy idea:​

○​ Iterate over start times​

○​ If a meeting starts before the earliest ending meeting → need new room​

○​ Else → reuse room (increment pointers)​

🧠 Approach
1.​ Extract startTimes and endTimes from intervals and sort both.​

2.​ Initialize:​

○​ rooms = 0 → current rooms​

○​ endPtr = 0 → pointer for endTimes​

3.​ Iterate over startTimes:​

○​ If startTimes[i] < endTimes[endPtr] → overlap → rooms++​

○​ Else → meeting ended → reuse room → endPtr++​

4.​ Return rooms​

💻 Java Code (With Comments)

import java.util.*;
public class MeetingRoomsII {

public static int minMeetingRooms(int[][] intervals) {

int n = intervals.length;

if (n == 0) return 0;

int[] startTimes = new int[n];

int[] endTimes = new int[n];

// Separate start and end times

for (int i = 0; i < n; i++) {

startTimes[i] = intervals[i][0];

endTimes[i] = intervals[i][1];

Arrays.sort(startTimes);

Arrays.sort(endTimes);

int rooms = 0;

int endPtr = 0;

// Iterate over meetings

for (int i = 0; i < n; i++) {

if (startTimes[i] < endTimes[endPtr]) {

// Need new room

rooms++;
 } else {

// Reuse room

endPtr++;

return rooms;

// Driver code

public static void main(String[] args) {

int[][] intervals1 = {{0,30},{5,10},{15,20}};

int[][] intervals2 = {{7,10},{2,4}};

System.out.println("Minimum rooms (1): " +

minMeetingRooms(intervals1)); // 2

System.out.println("Minimum rooms (2): " +

minMeetingRooms(intervals2)); // 1

🔍 Dry Run Example

Input: [[0,30],[5,10],[15,20]]

●​ startTimes: [0,5,15], endTimes: [10,20,30]​

●​ i=0 → 0 < 10 → rooms=1​

 ●​ i=1 → 5 < 10 → rooms=2​

●​ i=2 → 15 >= 10 → reuse room → endPtr++​

●​ Total rooms needed = 2​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n log n) Sorting start and end times

Space O(n) Arrays for start and end

times

⚙️ Edge Cases
Input Output Reason

No meetings 0 No rooms needed

Non-overlapping meetings 1 Single room sufficient

All meetings overlap n One room per

meeting

🧩 Key Takeaways
●​ Greedy + Sorting: Track start and end times to find maximum overlap.​
 ●​ Pattern useful for interval scheduling and resource allocation.​

●​ Efficient: O(n log n) time, O(n) space.​

Perfect 😎 ​
Let’s continue with the next Intervals problem.

🧩 Problem 76: Minimum Interval to Include Each

Query (Overall Count: 76 / 150)

📝 Problem Statement
You are given a list of intervals intervals[i] = [starti, endi] and an array of
queries queries[j].

●​ For each query queries[j], find the size of the smallest interval [starti,
endi] such that starti <= queries[j] <= endi.​

●​ If no such interval exists for a query, return -1.​

Return an array of answers for all queries.

🔹 Example 1
Input: intervals = [[1,4],[2,4],[3,6]], queries = [2,3,4,5]

Output: [3,3,3,4]

Explanation:

Query 2 → intervals [1,4],[2,4] → sizes 4,3 → min=3

Query 3 → intervals [1,4],[2,4],[3,6] → sizes 4,3,4 → min=3

Query 4 → intervals [1,4],[2,4],[3,6] → sizes 4,3,4 → min=3

Query 5 → intervals [3,6] → size=4

🔹 Example 2
Input: intervals = [[1,2],[3,4]], queries = [2,3]

Output: [2,2]

💡 Intuition
●​ For each query, we need the smallest interval containing it.​

●​ Greedy approach:​

○​ Sort intervals by start​

○​ Use a min-heap to keep track of intervals that cover current query by size​

○​ Pop intervals that end before the query​

○​ Top of heap → smallest interval covering query​

🧠 Approach
1.​ Sort intervals by start.​

2.​ Sort queries with their original indices.​

3.​ Initialize a min-heap (priority queue) storing [size, end].​

4.​ For each query in sorted order:​

○​ Push all intervals starting ≤ query into heap with size = end - start + 1.​

○​ Remove intervals from heap with end < query.​

○​ If heap not empty → answer = heap top size, else -1​

5.​ Map answers back to original query order.​

💻 Java Code (With Comments)
import java.util.*;

public class MinIntervalForQuery {

public static int[] minInterval(int[][] intervals, int[] queries) {

Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));

int n = queries.length;

int[] result = new int[n];

// Pair queries with their original indices

int[][] queryWithIndex = new int[n][2];

for (int i = 0; i < n; i++) {

queryWithIndex[i][0] = queries[i];

queryWithIndex[i][1] = i;

Arrays.sort(queryWithIndex, (a, b) -> Integer.compare(a[0], b[0]));

PriorityQueue<int[]> minHeap = new PriorityQueue<>((a, b) ->

Integer.compare(a[0], b[0]));

int i = 0;

for (int[] q : queryWithIndex) {

int query = q[0];

 int idx = q[1];

// Push intervals that start <= query

while (i < intervals.length && intervals[i][0] <= query) {

int size = intervals[i][1] - intervals[i][0] + 1;

minHeap.offer(new int[]{size, intervals[i][1]});

i++;

// Remove intervals that end before query

while (!minHeap.isEmpty() && minHeap.peek()[1] < query) {

minHeap.poll();

result[idx] = minHeap.isEmpty() ? -1 : minHeap.peek()[0];

return result;

// Driver code

public static void main(String[] args) {

int[][] intervals1 = {{1,4},{2,4},{3,6}};

int[] queries1 = {2,3,4,5};

int[][] intervals2 = {{1,2},{3,4}};

 int[] queries2 = {2,3};

System.out.println("Results 1: " +
Arrays.toString(minInterval(intervals1, queries1))); // [3,3,3,4]

System.out.println("Results 2: " +
Arrays.toString(minInterval(intervals2, queries2))); // [2,2]

🔍 Dry Run Example

Input: intervals = [[1,4],[2,4],[3,6]], queries = [2,3,4,5]

1.​ Sort intervals: [[1,4],[2,4],[3,6]]​

2.​ Process query 2:​

○​ Push [1,4] → size=4​

○​ Push [2,4] → size=3​

○​ Heap: [3,4], [4,4] → min size = 3​

3.​ Process query 3:​

○​ Push [3,6] → size=4​

○​ Heap: [3,4],[4,4],[4,6] → min size = 3​

4.​ Process query 4:​

○​ Heap: [3,4],[4,4],[4,6] → min size = 3​

5.​ Process query 5:​

○​ Remove intervals ending < 5 → remove [3,4] & [4,4]​

○​ Heap: [4,6] → min size = 4​

✅ Output: [3,3,3,4]
📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n log n + m log n) n=intervals, m=queries; sorting + heap

operations

Space O(n) Heap storage for intervals

⚙️ Edge Cases
Input Output Reason

Query outside all intervals -1 No interval covers it

Query inside multiple intervals Return Greedy heap selects

smallest minimum

🧩 Key Takeaways
●​ Greedy + Heap: Maintain smallest covering interval for current query.​

●​ Sort queries and intervals → process efficiently.​

●​ Efficient solution: O(n log n + m log n) time, O(n) space.​

MATH & GEOMETRY

Perfect 😎
​
Now we move to the Math & Geometry section.

🧩 Problem 77: Rotate Image (Overall Count: 77 / 150)

📝 Problem Statement
You are given an n x n 2D matrix matrix representing an image.

●​ Task: Rotate the image 90 degrees clockwise in-place.​

🔹 Example 1
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [[7,4,1],[8,5,2],[9,6,3]]

🔹 Example 2
Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

💡 Intuition
●​ Observation: 90° rotation = transpose + reverse each row​

1.​ Transpose the matrix: swap matrix[i][j] with matrix[j][i]​

2.​ Reverse each row​

●​ This rotates the matrix clockwise in-place.​

🧠 Approach
1.​ Transpose the matrix:​

○​ Swap elements above the diagonal: matrix[i][j] ↔ matrix[j][i] for

i<j​

2.​ Reverse each row:​

○​ For each row, swap matrix[i][j] ↔ matrix[i][n-1-j]​

3.​ Matrix is now rotated 90° clockwise.​

💻 Java Code (With Comments)

import java.util.*;

public class RotateImage {

public static void rotate(int[][] matrix) {

int n = matrix.length;

// Step 1: Transpose the matrix

for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
// Swap matrix[i][j] with matrix[j][i]
int temp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = temp;
}
}

// Step 2: Reverse each row

for (int i = 0; i < n; i++) {
int left = 0, right = n - 1;
while (left < right) {
int temp = matrix[i][left];
matrix[i][left] = matrix[i][right];
matrix[i][right] = temp;
left++;
right--;
}
}
 }

// Driver code
public static void main(String[] args) {
int[][] matrix1 = {{1,2,3},{4,5,6},{7,8,9}};
int[][] matrix2 = {{5,1,9,11},{2,4,8,10},{13,3,6,7},{15,14,12,16}};

rotate(matrix1);
System.out.println("Rotated Matrix 1: " +
Arrays.deepToString(matrix1));

rotate(matrix2);
System.out.println("Rotated Matrix 2: " +
Arrays.deepToString(matrix2));
}
}

🔍 Dry Run Example

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

1.​ Transpose:​

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

2.​ Reverse rows:​

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

✅ Rotated 90° clockwise

📊 Complexity Analysis
 Aspec Complexity Explanation
t

Time O(n²) Two passes over n×n

matrix

Space O(1) In-place rotation

⚙️ Edge Cases
Input Output Reason

1x1 matrix Same No rotation needed

2x2 matrix Rotated Works with transpose +

90° reverse

🧩 Key Takeaways
●​ Transpose + Reverse rows → standard in-place 90° clockwise rotation.​

●​ No extra space needed → O(1) space.​

●​ Pattern useful for matrix manipulation problems.​

Perfect 😎 ​
Let’s continue with the next Math & Geometry problem.

🧩 Problem 78: Spiral Matrix (Overall Count: 78 / 150)

📝 Problem Statement
Given an m x n matrix, return all elements of the matrix in spiral order (clockwise starting
from top-left).

🔹 Example 1
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]

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

🔹 Example 2
Input: matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]

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

💡 Intuition
●​ Traverse the matrix layer by layer (outer to inner):​

1.​ Top row → left to right​

2.​ Right column → top to bottom​

3.​ Bottom row → right to left​

4.​ Left column → bottom to top​

●​ After each layer, shrink boundaries and continue.​

🧠 Approach
1.​ Initialize boundaries: top=0, bottom=m-1, left=0, right=n-1​

2.​ While top <= bottom && left <= right:​

○​ Traverse top row → left to right → top++​

○​ Traverse right column → top to bottom → right--​

○​ Traverse bottom row → right to left → bottom-- (if top ≤ bottom)​

○​ Traverse left column → bottom to top → left++ (if left ≤ right)​

 3.​ Collect elements in order → result list​

💻 Java Code (With Comments)

import java.util.*;

public class SpiralMatrix {

public static List<Integer> spiralOrder(int[][] matrix) {

List<Integer> result = new ArrayList<>();

if (matrix.length == 0) return result;

int top = 0, bottom = matrix.length - 1;

int left = 0, right = matrix[0].length - 1;

while (top <= bottom && left <= right) {

// Traverse top row

for (int i = left; i <= right; i++) {

result.add(matrix[top][i]);

top++;

// Traverse right column

for (int i = top; i <= bottom; i++) {

result.add(matrix[i][right]);

}
 right--;

// Traverse bottom row

if (top <= bottom) {

for (int i = right; i >= left; i--) {

result.add(matrix[bottom][i]);

bottom--;

// Traverse left column

if (left <= right) {

for (int i = bottom; i >= top; i--) {

result.add(matrix[i][left]);

left++;

return result;

// Driver code

public static void main(String[] args) {

int[][] matrix1 = {{1,2,3},{4,5,6},{7,8,9}};

int[][] matrix2 = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

 System.out.println("Spiral Order 1: " + spiralOrder(matrix1)); //
[1,2,3,6,9,8,7,4,5]

System.out.println("Spiral Order 2: " + spiralOrder(matrix2)); //

[1,2,3,4,8,12,11,10,9,5,6,7]

🔍 Dry Run Example

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

1.​ Top row: [1,2,3] → top=1​

2.​ Right column: [6,9] → right=1​

3.​ Bottom row: [8,7] → bottom=1​

4.​ Left column: [4] → left=1​

5.​ Top row (inner): [5] → done​

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

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(m×n) Each element visited

once

Space O(1) extra Result list stores

elements
⚙️ Edge Cases
Input Output Reason

Empty matrix [] Nothing to traverse

Single row/column Return Handles single-line spiral

as-is

🧩 Key Takeaways
●​ Layer-by-layer traversal for spiral problems.​

●​ Carefully manage boundaries (top, bottom, left, right).​

●​ Pattern works for matrix traversal and simulation problems.​

Perfect😎 ​
Let’s continue with the next Math & Geometry problem.

🧩 Problem 79: Set Matrix Zeroes (Overall Count: 79 /

150)

📝 Problem Statement
Given an m x n matrix, if an element is 0, set its entire row and column to 0.

●​ Task: Do this in-place.​

🔹 Example 1
Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]

Output: [[1,0,1],[0,0,0],[1,0,1]]

🔹 Example 2
Input: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]

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

💡 Intuition
●​ Naive: Use extra arrays to mark rows and columns → O(m+n) space​

●​ Optimal (in-place):​

○​ Use first row and first column as markers​

○​ Separate flags for first row and first column to avoid overwriting​

🧠 Approach
1.​ Check if first row or first column contain 0 → store in row0 and col0​

2.​ For the rest of the matrix:​

○​ If matrix[i][j] == 0 → mark matrix[i][0] = 0, matrix[0][j] =

0​

3.​ Iterate again (except first row & column):​

○​ If matrix[i][0] == 0 or matrix[0][j] == 0 → set matrix[i][j] =

0​

4.​ Update first row/column if needed​

💻 Java Code (With Comments)
import java.util.*;

public class SetMatrixZeroes {

public static void setZeroes(int[][] matrix) {

int m = matrix.length;

int n = matrix[0].length;

boolean row0 = false, col0 = false;

// Check if first row has zero

for (int j = 0; j < n; j++) {

if (matrix[0][j] == 0) row0 = true;

// Check if first column has zero

for (int i = 0; i < m; i++) {

if (matrix[i][0] == 0) col0 = true;

// Use first row and column as markers

for (int i = 1; i < m; i++) {

for (int j = 1; j < n; j++) {

if (matrix[i][j] == 0) {
 matrix[i][0] = 0;

matrix[0][j] = 0;

// Set zeroes based on markers

for (int i = 1; i < m; i++) {

for (int j = 1; j < n; j++) {

if (matrix[i][0] == 0 || matrix[0][j] == 0) {

matrix[i][j] = 0;

// Set first row/column if needed

if (row0) {

for (int j = 0; j < n; j++) matrix[0][j] = 0;

if (col0) {

for (int i = 0; i < m; i++) matrix[i][0] = 0;

// Driver code

public static void main(String[] args) {

 int[][] matrix1 = {{1,1,1},{1,0,1},{1,1,1}};

int[][] matrix2 = {{0,1,2,0},{3,4,5,2},{1,3,1,5}};

setZeroes(matrix1);

System.out.println("Matrix 1: " + Arrays.deepToString(matrix1));

setZeroes(matrix2);

System.out.println("Matrix 2: " + Arrays.deepToString(matrix2));

🔍 Dry Run Example

Input: [[1,1,1],[1,0,1],[1,1,1]]

1.​ First row → no zero​

2.​ First column → no zero​

3.​ Mark zeros: matrix[1][0]=0, matrix[0][1]=0​

4.​ Set zeros based on markers:​

○​ Row 1 → zero​

○​ Column 1 → zero​

5.​ First row/column unchanged​

✅ Output: [[1,0,1],[0,0,0],[1,0,1]]

📊 Complexity Analysis
 Aspec Complexity Explanation
t

Time O(m×n) Two passes over the matrix

Space O(1) In-place using first row & column as markers

⚙️ Edge Cases
Input Output Reason

All zeros Same Matrix remains zeros

Single row/column Update correctly Works for m=1 or n=1

🧩 Key Takeaways
●​ In-place marker technique reduces space from O(m+n) → O(1).​

●​ Useful for matrix manipulation and simulation problems.​

●​ Carefully handle first row and first column separately.​

Perfect 😎 ​
Let’s continue with the next Math & Geometry problem.

🧩 Problem 80: Happy Number (Overall Count: 80 / 150)

📝 Problem Statement
A happy number is defined by the following process:

1.​ Starting with any positive integer n, replace the number by the sum of the squares
of its digits.​

2.​ Repeat the process until the number equals 1 (where it will stay), or it loops
endlessly in a cycle that does not include 1.​

3.​ If it ends in 1, the number is happy. Otherwise, it is not happy.​

●​ Task: Determine if a given number n is a happy number.​

🔹 Example 1
Input: n = 19

Output: true

Explanation:

19 → 1²+9² = 82

82 → 8²+2² = 68

68 → 6²+8² = 100

100 → 1²+0²+0² = 1

🔹 Example 2
Input: n = 2

Output: false

💡 Intuition
●​ Repeated sum-of-squares process can enter a loop if number is not happy.​
 ●​ Use a set to track numbers already seen:​

○​ If we see the same number again → loop → not happy​

○​ If we reach 1 → happy​

🧠 Approach
1.​ Initialize Set<Integer> seen.​

2.​ While n != 1:​

○​ If n is in seen → return false (loop)​

○​ Add n to seen​

○​ Replace n with sum of squares of its digits​

3.​ If n == 1 → return true​

💻 Java Code (With Comments)

import java.util.*;

public class HappyNumber {

// Helper function to calculate sum of squares of digits

private static int sumOfSquares(int n) {

int sum = 0;

while (n > 0) {

int digit = n % 10;

sum += digit * digit;

 n /= 10;

return sum;

public static boolean isHappy(int n) {

Set<Integer> seen = new HashSet<>();

while (n != 1) {

if (seen.contains(n)) {

// Loop detected → not happy

return false;

seen.add(n);

n = sumOfSquares(n);

return true; // Reached 1 → happy number

// Driver code

public static void main(String[] args) {

int n1 = 19;

int n2 = 2;

System.out.println("Is 19 happy? " + isHappy(n1)); // true

 System.out.println("Is 2 happy? " + isHappy(n2)); // false

🔍 Dry Run Example

Input: n = 19

1.​ 19 → 1²+9² = 82​

2.​ 82 → 8²+2² = 68​

3.​ 68 → 6²+8² = 100​

4.​ 100 → 1²+0²+0² = 1 → happy​

✅ Output: true

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(log n × log n) Each number ≤ n has log n digits, each digit
squared

Space O(log n) HashSet stores numbers in the loop

⚙️ Edge Cases
Input Output Reason
 n=1 true Already happy

n=0 false Loops in zero → not happy

🧩 Key Takeaways
●​ Cycle detection in iterative processes → HashSet is handy.​

●​ Can also use Floyd’s cycle detection to avoid extra space.​

●​ Pattern appears in number transformation and loop detection problems.​

Perfect 😎 ​
Let’s continue with the next Math & Geometry problem.

🧩 Problem 81: Plus One (Overall Count: 81 / 150)

📝 Problem Statement
You are given a non-empty array of decimal digits representing a non-negative integer,
where the most significant digit is at the head of the list.

●​ Task: Increment the integer by one and return the resulting array of digits.​

●​ Note: The integer does not contain leading zeros, except the number 0 itself.​

🔹 Example 1
Input: digits = [1,2,3]

Output: [1,2,4]

Explanation: 123 + 1 = 124

🔹 Example 2
Input: digits = [9,9,9]

Output: [1,0,0,0]

Explanation: 999 + 1 = 1000

💡 Intuition
●​ Start from the least significant digit (rightmost).​

●​ Add one and handle carry:​

○​ If sum < 10 → done​

○​ Else → set digit = 0, carry = 1, move left​

●​ If carry remains after leftmost digit → prepend 1​

🧠 Approach
1.​ Initialize carry = 1 (for plus one)​

2.​ Iterate from last index to first:​

○​ sum = digits[i] + carry​

○​ digits[i] = sum % 10​

○​ carry = sum / 10​

3.​ If carry == 1 after loop → prepend 1 at front​

4.​ Return updated array​

💻 Java Code (With Comments)
import java.util.*;

public class PlusOne {

public static int[] plusOne(int[] digits) {

int n = digits.length;

int carry = 1; // Start with +1

for (int i = n - 1; i >= 0; i--) {

int sum = digits[i] + carry;

digits[i] = sum % 10; // Update current digit

carry = sum / 10; // Update carry

if (carry == 1) {

// All digits were 9, need extra digit at front

int[] result = new int[n + 1];

result[0] = 1;

return result;

return digits;

// Driver code
 public static void main(String[] args) {

int[] digits1 = {1,2,3};

int[] digits2 = {9,9,9};

System.out.println("Plus one 1: " +

Arrays.toString(plusOne(digits1))); // [1,2,4]

System.out.println("Plus one 2: " +

Arrays.toString(plusOne(digits2))); // [1,0,0,0]

🔍 Dry Run Example

Input: [1,2,3]

1.​ i=2 → 3+1=4 → digit=4, carry=0​

✅
2.​ i=1 → carry=0 → break​
Output: [1,2,4]​

Input: [9,9,9]

1.​ i=2 → 9+1=10 → digit=0, carry=1​

2.​ i=1 → 9+1=10 → digit=0, carry=1​

3.​ i=0 → 9+1=10 → digit=0, carry=1​

4.​ carry=1 → prepend 1 → [1,0,0,0]​

📊 Complexity Analysis
 Aspec Complexity Explanation
t

Time O(n) Single pass from right to left

Space O(1) extra (O(n) if new array In-place update; only new array if all digits
needed) are 9

⚙️ Edge Cases
Input Output Reason

[0] [1] Simple increment

All 9s New array with 1 at front Carryover

propagates

🧩 Key Takeaways
●​ Classic carry propagation problem.​

●​ Reverse iteration simplifies handling least significant digit first.​

●​ Useful pattern for array-based arithmetic operations.​

Perfect 😎​
Let’s continue with the next Math & Geometry problem.

🧩 Problem 82: Pow(x, n) (Overall Count: 82 / 150)

📝 Problem Statement
Implement pow(x, n), which calculates x raised to the power n (x^n).

●​ Task: Compute x^n efficiently.​

🔹 Example 1
Input: x = 2.0, n = 10

Output: 1024.0

🔹 Example 2
Input: x = 2.1, n = 3

Output: 9.261

🔹 Example 3
Input: x = 2.0, n = -2

Output: 0.25

Explanation: 2^-2 = 1/(2^2) = 0.25

💡 Intuition
●​ Naive approach: Multiply x n times → O(n) → slow for large n​

●​ Optimized approach: Binary exponentiation​

○​ Use property:​

■​ If n is even → x^n = (x^(n/2))^2​

 ■​ If n is odd → x^n = x * x^(n-1)​

●​ Works for negative powers too → 1/(x^-n)​

🧠 Approach
1.​ Handle negative n → use 1/x and -n.​

2.​ Initialize result = 1.​

3.​ While n > 0:​

○​ If n is odd → result *= x​

○​ x = x * x​

○​ n = n / 2​

4.​ Return result​

💻 Java Code (With Comments)

public class PowXN {

public static double myPow(double x, int n) {

long N = n; // Convert to long to handle Integer.MIN_VALUE

if (N < 0) {

x = 1 / x;

N = -N;

double result = 1.0;

 while (N > 0) {

if (N % 2 == 1) {

// Multiply result by current x if exponent is odd

result *= x;

// Square x for next bit

x *= x;

N /= 2; // Divide exponent by 2

return result;

// Driver code

public static void main(String[] args) {

System.out.println("2^10 = " + myPow(2.0, 10)); // 1024.0

System.out.println("2.1^3 = " + myPow(2.1, 3)); // 9.261

System.out.println("2^-2 = " + myPow(2.0, -2)); // 0.25

🔍 Dry Run Example

Input: x=2, n=10

1.​ N=10, result=1​

 2.​ N=10 → even → x=4, N=5​

3.​ N=5 → odd → result=1*4=4, x=16, N=2​

4.​ N=2 → even → x=256, N=1​

✅
5.​ N=1 → odd → result=4*256=1024, x=65536, N=0​
Output: 1024​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(log n) Exponent halved each

step

Space O(1) Iterative solution

⚙️ Edge Cases
Input Output Reason

n=0 1 x^0 = 1

x=0, n>0 0 Multiplication by zero

n<0 Return 1/x^-n Negative powers

handled
🧩 Key Takeaways
●​ Binary exponentiation is efficient → O(log n)​

●​ Handles negative powers and large exponents carefully​

●​ Pattern appears in modular exponentiation and fast power problems​

Perfect😎 ​
I will give you Problem 83: Multiply Strings from scratch, fully detailed with problem
statement, examples, intuition, approach, code with proper comments, dry run, complexity,
and key takeaways.

🧩 Problem 83: Multiply Strings (Overall Count: 83 /

150)

📝 Problem Statement
Given two non-negative integers num1 and num2 represented as strings, return their
product, also as a string.

●​ You cannot convert the input strings directly to integers because the numbers
may be very large.​

●​ Perform manual multiplication simulation.​

🔹 Example 1
Input: num1 = "2", num2 = "3"

Output: "6"

🔹 Example 2
Input: num1 = "123", num2 = "456"
Output: "56088"

🔹 Example 3
Input: num1 = "0", num2 = "999"

Output: "0"

💡 Intuition
●​ Multiplication can be done digit by digit, like on paper.​

●​ Store intermediate results in an array.​

●​ Handle carry separately.​

●​ Finally, convert the array into a string, skipping leading zeros.​

🧠 Approach
1.​ Initialize an array result of size m + n (maximum digits possible).​

2.​ Multiply digits from right to left:​

○​ For num1[i] and num2[j], multiply and add to result[i+j+1].​

3.​ Handle carry:​

○​ result[i+j] += result[i+j+1] / 10​

○​ result[i+j+1] %= 10​

4.​ Convert the result array into a string, skipping leading zeros.​

5.​ If the string is empty, return "0" (when both inputs are zero).​
💻 Java Code (With Comments)
import java.util.*;

public class MultiplyStrings {

public static String multiply(String num1, String num2) {

int m = num1.length();

int n = num2.length();

int[] result = new int[m + n]; // Maximum possible digits for

multiplication

// Step 1: Multiply each digit of num1 with each digit of num2

for (int i = m - 1; i >= 0; i--) {

int d1 = num1.charAt(i) - '0'; // Convert char to int

for (int j = n - 1; j >= 0; j--) {

int d2 = num2.charAt(j) - '0';

result[i + j + 1] += d1 * d2; // Add product to the correct

position

// Step 2: Handle carry for each position

for (int i = m + n - 1; i > 0; i--) {

result[i - 1] += result[i] / 10; // Carry to the left

result[i] %= 10; // Remainder stays

}
 // Step 3: Convert array to string, skipping leading zeros

StringBuilder sb = new StringBuilder();

int index = 0;

while (index < result.length && result[index] == 0) index++; // Skip

leading zeros

for (; index < result.length; index++) sb.append(result[index]);

return sb.length() == 0 ? "0" : sb.toString(); // If result is zero

// Driver code

public static void main(String[] args) {

String num1 = "123";

String num2 = "456";

String num3 = "0";

String num4 = "999";

System.out.println("123 * 456 = " + multiply(num1, num2)); // 56088

System.out.println("0 * 999 = " + multiply(num3, num4)); // 0

System.out.println("99 * 99 = " + multiply("99", "99")); // 9801

🔍 Dry Run Example

Input: num1 = "123", num2 = "456"

1.​ Initialize result array: [0,0,0,0,0,0]​

2.​ Multiply digits:​

○​ 3*6 → result[5] += 18 → result: [0,0,0,0,1,8]​

○​ 3*5 → result[4] += 15 → result: [0,0,0,1,6,8]​

○​ Continue for all digits​

3.​ Handle carry for each position:​

○​ result[4] = 6 → carry 1 → result[3] += 1​

○​ Continue for all positions​

4.​ Convert array to string, skipping leading zeros → "56088"​

✅ Output: "56088"

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(m × n) Multiply every digit of num1 with every digit of num2

Space O(m + n) Result array to store digits

⚙️ Edge Cases
Input Output Reason
 "0" × any "0" Multiplication with zero

Very large Works Handles big numbers as

numbers strings

Leading zeros Skipped in output Result always valid

🧩 Key Takeaways
●​ Manual multiplication can be simulated using an array for digits.​

●​ Carry handling is crucial for correct results.​

●​ Pattern is useful for big integer arithmetic without built-in libraries.​

Perfect😎 ​
Let’s continue with the next Math & Geometry problem.

🧩 Problem 84: Detect Squares (Overall Count: 84 / 150)

📝 Problem Statement
You are given a set of points in the 2D plane that can be added dynamically.

●​ Task: Implement a data structure to add points and count the number of squares
that can be formed with the given points and a query point as one of the corners.​

Operations:

1.​ add(point): Adds a point to the data structure.​

 2.​ count(point): Counts the number of squares with sides parallel to axes where the
given point is one of the corners.​

🔹 Example
add([3, 10])

add([11, 2])

add([3, 2])

count([11, 10]) → 1

Explanation:​
Points [3,10], [3,2], [11,2], [11,10] form a square with [11,10] as one corner.

💡 Intuition
●​ A square with sides parallel to axes:​

○​ If we know two points sharing same x or y, we can determine the potential

square corners.​

●​ Use a hash map of points with counts to efficiently check for potential squares.​

🧠 Approach
1.​ Store points and their counts in a map: Map<Integer, Map<Integer,
Integer>>.​

2.​ For count(point):​

○​ Iterate all points sharing x-coordinate or y-coordinate with query point.​

○​ Check if corresponding opposite corners exist in map.​

○​ Multiply counts to get number of squares.​

💻 Java Code (With Comments)
import java.util.*;

class DetectSquares {

// Map to store count of points at (x, y)

private Map<Integer, Map<Integer, Integer>> pointCount;

public DetectSquares() {

pointCount = new HashMap<>();

public void add(int[] point) {

int x = point[0], y = point[1];

pointCount.putIfAbsent(x, new HashMap<>());

Map<Integer, Integer> yCount = pointCount.get(x);

yCount.put(y, yCount.getOrDefault(y, 0) + 1);

public int count(int[] point) {

int res = 0;

int x = point[0], y = point[1];

if (!pointCount.containsKey(x)) return 0;

Map<Integer, Integer> yMap = pointCount.get(x);

 // Iterate all possible y-coordinates for same x

for (int colY : yMap.keySet()) {

if (colY == y) continue; // Skip same point

int d = colY - y; // distance

// Check for squares on both sides (x+d, x-d)

res += getCount(x + d, y, x + d, colY) * yMap.get(colY);

res += getCount(x - d, y, x - d, colY) * yMap.get(colY);

return res;

// Helper to get count of two points forming a square

private int getCount(int x1, int y1, int x2, int y2) {

if (!pointCount.containsKey(x1)) return 0;

Map<Integer, Integer> map = pointCount.get(x1);

if (!map.containsKey(y1) || !map.containsKey(y2)) return 0;

return map.get(y1) * map.get(y2);

// Driver code

public static void main(String[] args) {

DetectSquares ds = new DetectSquares();

ds.add(new int[]{3,10});

ds.add(new int[]{11,2});

ds.add(new int[]{3,2});
 System.out.println("Count([11,10]) = " + ds.count(new int[]{11,10}));
// 1

🔍 Dry Run Example

Points added: [3,10], [11,2], [3,2]​
Query: [11,10]

1.​ Same x: [11,2] → distance d = 10-2 = 8​

2.​ Check [3,10] and [3,2] → exist → count = 1​

✅ Output: 1

📊 Complexity Analysis
Aspect Complexity Explanation

Time (add) O(1) Map insertion

Time (count) O(n) Iterate points with same

x

Space O(n) Store points in map

⚙️ Edge Cases
Input Output Reason
 No points 0 Cannot form
square

Duplicate points Count multiple Use counts in map

squares

🧩 Key Takeaways
●​ Use hash maps of coordinates to count geometric patterns.​

●​ Multiplying counts handles duplicate points.​

●​ Efficient for problems involving dynamic geometric shapes.​

BitManipulation

Perfect😎 ​
Let’s continue with the next Bit Manipulation problem.

🧩 Problem 85: Single Number (Overall Count: 85 / 150)

📝 Problem Statement
Given a non-empty array of integers nums, every element appears twice except for one.

●​ Task: Find the element that appears only once.​

●​ Your solution must have linear runtime complexity and use constant extra space.​

🔹 Example 1
Input: nums = [2,2,1]
Output: 1

🔹 Example 2
Input: nums = [4,1,2,1,2]
Output: 4

💡 Intuition
●​ Use XOR (^) property:​

○​ x ^ x = 0​

○​ x ^ 0 = x​

●​ XOR all numbers:​

○​ Duplicates cancel out → only single number remains.​

🧠 Approach
1.​ Initialize single = 0.​

2.​ Iterate through nums:​

○​ single ^= num​

3.​ Return single.​

💻 Java Code (With Comments)

public class SingleNumber {

public static int singleNumber(int[] nums) {

int single = 0;

// XOR all elements

for (int num : nums) {
 single ^= num; // duplicates cancel out
}

return single;
}

// Driver code
public static void main(String[] args) {
int[] nums1 = {2,2,1};
int[] nums2 = {4,1,2,1,2};

System.out.println("Single Number 1: " + singleNumber(nums1)); // 1

System.out.println("Single Number 2: " + singleNumber(nums2)); // 4
}
}

🔍 Dry Run Example

Input: [4,1,2,1,2]

1.​ single=0​

2.​ 0^4=4​

3.​ 4^1=5​

4.​ 5^2=7​

5.​ 7^1=6​

6.​ 6^2=4 ✅ Output: 4​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass through array

Space O(1) Constant space using

XOR
⚙️ Edge Cases
Input Output Reason

Single element Element itself No duplicates

All duplicates except one Correctly finds single XOR cancels

duplicates

🧩 Key Takeaways
●​ XOR is powerful for finding single unique numbers.​

●​ Works when every element appears exactly twice except one.​

●​ No extra space required → very efficient.​

Perfect 😎 ​
Let’s continue with the next Bit Manipulation problem.

🧩 Problem 86: Number of 1 Bits (Overall Count: 86 /

150)

📝 Problem Statement
Write a function that takes an unsigned integer and returns the number of '1' bits it has
(also known as the Hamming weight).

🔹 Example 1
Input: n = 11 (binary 1011)
Output: 3

🔹 Example 2
Input: n = 128 (binary 10000000)
Output: 1

💡 Intuition
●​ Count number of bits set to 1.​

●​ Can use bit manipulation techniques:​

1.​ Check each bit by shifting​

2.​ Use n & (n-1) trick to remove lowest set bit​

🧠 Approach
Method 1: Shift and Count

1.​ Initialize count = 0.​

2.​ While n != 0:​

○​ count += n & 1 → checks last bit​

○​ n >>= 1 → shift right​

3.​ Return count.​

Method 2: Brian Kernighan’s Algorithm (Optimized)

1.​ While n != 0:​

○​ n = n & (n-1) → removes last set bit​

○​ Increment count​

💻 Java Code (With Comments, Optimized)

public class NumberOf1Bits {

// Using Brian Kernighan's algorithm

 public static int hammingWeight(int n) {
int count = 0;

while (n != 0) {
n = n & (n - 1); // Remove lowest set bit
count++;
}

return count;
}

// Driver code
public static void main(String[] args) {
int n1 = 11; // binary 1011
int n2 = 128; // binary 10000000

System.out.println("Hamming weight of 11: " + hammingWeight(n1));

// 3
System.out.println("Hamming weight of 128: " + hammingWeight(n2));
// 1
}
}

🔍 Dry Run Example

Input: n = 11 (1011)

1.​ n=11 → 1011 & 1010 = 1010 → count=1​

2.​ n=10 → 1010 & 1001 = 1000 → count=2​

3.​ n=8 → 1000 & 0111 = 0 → count=3​

✅ Output: 3

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(k) k = number of set bits

 Space O(1) Constant extra space

⚙️ Edge Cases
Input Output Reason

n=0 0 No bits set

n = all 1s Number of bits Counts all ones correctly

🧩 Key Takeaways
●​ Brian Kernighan’s trick is efficient → O(number of set bits)​

●​ Useful in bit manipulation problems​

●​ Avoids checking every bit individually for large numbers​

Perfect 😎 ​
Let’s continue with the next Bit Manipulation problem.

🧩 Problem 87: Counting Bits (Overall Count: 87 / 150)

📝 Problem Statement
Given an integer n, return an array ans of length n + 1 where ans[i] is the number of 1
bits in the binary representation of i (0 ≤ i ≤ n).

🔹 Example 1
Input: n = 2
Output: [0,1,1]
Explanation:
0 -> 0b0 → 0 ones
1 -> 0b1 → 1 one
2 -> 0b10 → 1 one
🔹 Example 2
Input: n = 5
Output: [0,1,1,2,1,2]

💡 Intuition
●​ Counting bits for each number individually works (O(n log n))​

●​ Can optimize using dynamic programming:​

○​ ans[i] = ans[i >> 1] + (i & 1)​

■​ Right shift by 1 → previous number​

■​ Last bit → add 0 or 1​

🧠 Approach
1.​ Initialize ans[0] = 0.​

2.​ For i from 1 to n:​

○​ ans[i] = ans[i >> 1] + (i & 1)​

3.​ Return ans.​

💻 Java Code (With Comments)

import java.util.*;

public class CountingBits {

public static int[] countBits(int n) {

int[] ans = new int[n + 1];
ans[0] = 0; // 0 has zero 1 bits

for (int i = 1; i <= n; i++) {

ans[i] = ans[i >> 1] + (i & 1); // DP relation
}
 return ans;
}

// Driver code
public static void main(String[] args) {
int n1 = 2;
int n2 = 5;

System.out.println("Count bits up to 2: " +

Arrays.toString(countBits(n1))); // [0,1,1]
System.out.println("Count bits up to 5: " +
Arrays.toString(countBits(n2))); // [0,1,1,2,1,2]
}
}

🔍 Dry Run Example

Input: n=5

1.​ i=1 → 1>>1=0 → ans[1]=ans[0]+1=1​

2.​ i=2 → 2>>1=1 → ans[2]=ans[1]+0=1​

3.​ i=3 → 3>>1=1 → ans[3]=ans[1]+1=2​

4.​ i=4 → 4>>1=2 → ans[4]=ans[2]+0=1​

5.​ i=5 → 5>>1=2 → ans[5]=ans[2]+1=2​

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

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass from 1 to n

Space O(n) Output array of size n+1

⚙️ Edge Cases
Input Output Reason

n=0 [0] Only number 0

n=1 [0,1] Simple base

case

🧩 Key Takeaways
●​ DP optimization reduces counting bits from O(n log n) → O(n)​

●​ i >> 1 shifts right → uses previously computed result​

●​ Useful in bit manipulation and DP combined problems​

Perfect 😎 ​
Let’s continue with the next Bit Manipulation problem.

🧩 Problem 88: Reverse Bits (Overall Count: 88 / 150)

📝 Problem Statement
Reverse the bits of a 32-bit unsigned integer n and return the resulting integer.

🔹 Example 1
Input: n = 43261596 (binary 00000010100101000001111010011100)
Output: 964176192 (binary 00111001011110000010100101000000)

🔹 Example 2
Input: n = 4294967293 (binary 11111111111111111111111111111101)
Output: 3221225471 (binary 10111111111111111111111111111111)
💡 Intuition
●​ Treat integer as 32 bits.​

●​ Shift and accumulate bits from least significant to most significant.​

●​ Use bitwise operations:​

○​ (n & 1) → get last bit​

○​ << → shift bits to correct position​

🧠 Approach
1.​ Initialize result = 0.​

2.​ Iterate 32 times:​

○​ result = (result << 1) | (n & 1) → append last bit​

○​ n >>= 1 → remove last bit​

3.​ Return result.​

💻 Java Code (With Comments)

public class ReverseBits {

public static int reverseBits(int n) {

int result = 0;

for (int i = 0; i < 32; i++) {

result = (result << 1) | (n & 1); // Shift result left, add last
bit of n
n >>= 1; // Shift n right to process next bit
}

return result;
}

// Driver code
 public static void main(String[] args) {
int n1 = 43261596; // 00000010100101000001111010011100
int n2 = -3; // 11111111111111111111111111111101

System.out.println("Reversed 43261596: " + reverseBits(n1)); //

964176192
System.out.println("Reversed -3: " + reverseBits(n2)); //
3221225471
}
}

🔍 Dry Run Example

Input: n = 3 (binary 00000000000000000000000000000011)

1.​ i=0 → result=0<<1 | 1=1, n=1​

2.​ i=1 → result=1<<1 | 1=3, n=0​

✅
3.​ i=2→31 → result shifted, n=0​
Output: 3221225472 (32-bit reversed integer)​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(32) = O(1) Constant 32

iterations

Space O(1) Constant space

⚙️ Edge Cases
Input Output Reason

n=0 0 All zeros remain zero

n=All ones 429496729 Reversed all ones →

5 same
🧩 Key Takeaways
●​ Bitwise operations make bit reversal easy and efficient.​

●​ Works for fixed 32-bit integers.​

●​ Shift-and-append is a general method for bit manipulation problems.​

Perfect😎 ​
Let’s continue with the next Bit Manipulation problem.

🧩 Problem 89: Missing Number (Overall Count: 89 /

150)

📝 Problem Statement
Given an array nums containing n distinct numbers in the range [0, n], return the only
number missing from the array.

🔹 Example 1
Input: nums = [3,0,1]
Output: 2
Explanation: n = 3, numbers in range [0,3] are 0,1,2,3. Missing number = 2.

🔹 Example 2
Input: nums = [0,1]
Output: 2

💡 Intuition
●​ Sum of numbers from 0 to n is n*(n+1)/2​
 ●​ Subtract sum of array → missing number​

●​ Alternative: XOR trick:​

○​ XOR all indices and numbers → duplicates cancel → missing number

remains​

🧠 Approach
Method 1: XOR (Optimal)

1.​ Initialize missing = n (n is array length)​

2.​ Iterate i from 0 to n-1:​

○​ missing ^= i ^ nums[i]​

3.​ Return missing​

Reasoning:

●​ XOR of all numbers and indices cancels duplicates → only missing remains​

💻 Java Code (With Comments)

public class MissingNumber {

public static int missingNumber(int[] nums) {

int n = nums.length;
int missing = n; // Start with n

for (int i = 0; i < n; i++) {

missing ^= i ^ nums[i]; // XOR index and number
}

return missing;
}

// Driver code
public static void main(String[] args) {
int[] nums1 = {3,0,1};
 int[] nums2 = {0,1};

System.out.println("Missing number 1: " + missingNumber(nums1)); // 2

System.out.println("Missing number 2: " + missingNumber(nums2)); // 2
}
}

🔍 Dry Run Example

Input: [3,0,1], n=3

●​ missing=3​

●​ i=0 → missing=3^0^3=0​

●​ i=1 → missing=0^1^0=1​

●​ i=2 → missing=1^2^1=2 ✅ Output: 2​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(n) Single pass through array

Space O(1) Constant space using

XOR

⚙️ Edge Cases
Input Output Reason

Single element [0] 1 n=1, missing number is 1

Full range except Correctly returns missing XOR cancels all present
one numbers

🧩 Key Takeaways
 ●​ XOR is extremely useful for finding missing or unique elements.​

●​ Constant space, linear time.​

●​ Alternative method: sum formula n*(n+1)/2 - sum(nums).​

Perfect 😎 ​
Let’s continue with the next Bit Manipulation problem.

🧩 Problem 90: Sum of Two Integers (Overall Count: 90

/ 150)

📝 Problem Statement
Calculate the sum of two integers a and b without using the '+' or '-' operators.

🔹 Example 1
Input: a = 1, b = 2
Output: 3

🔹 Example 2
Input: a = -2, b = 3
Output: 1

💡 Intuition
●​ Use bit manipulation:​

1.​ XOR (^) → sum without carry​

2.​ AND (&) and shift → carry​

●​ Repeat until carry is 0​

Reasoning:

●​ XOR simulates addition ignoring carry​

●​ AND identifies carry positions​

●​ Shift carry left to add to the next higher bit​

🧠 Approach
1.​ Initialize sum = a, carry = b.​

2.​ While carry != 0:​

○​ temp = sum ^ carry → partial sum without carry​

○​ carry = (sum & carry) << 1 → carry shifted​

○​ sum = temp​

3.​ Return sum​

💻 Java Code (With Comments)

public class SumOfTwoIntegers {

public static int getSum(int a, int b) {

int sum = a;
int carry = b;

while (carry != 0) {
int temp = sum ^ carry; // sum without carry
carry = (sum & carry) << 1; // calculate carry
sum = temp; // update sum
}

return sum;
}

// Driver code
public static void main(String[] args) {
 System.out.println("1 + 2 = " + getSum(1, 2)); // 3
System.out.println("-2 + 3 = " + getSum(-2, 3)); // 1
System.out.println("-5 + -7 = " + getSum(-5, -7)); // -12
}
}

🔍 Dry Run Example

Input: a=1, b=2

1.​ sum=1, carry=2​

2.​ temp = 1 ^ 2 = 3, carry = (1 & 2)<<1 = 0​

✅
3.​ carry=0 → exit loop​
Output: 3​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(1) Max 32 iterations for 32-bit integers

Space O(1) Constant space

⚙️ Edge Cases
Input Output Reason

Both positive Sum positive Normal addition

Mixed sign Correct sum XOR + carry handles negative

numbers

Both negative Correct sum Works due to 2’s complement

🧩 Key Takeaways
●​ Bit manipulation can replace arithmetic operators.​
 ●​ XOR + AND + shift → basic sum logic.​

●​ Works for all integers in 32-bit range.​

Perfect 😎 ​
Let’s continue with the next Bit Manipulation problem.

🧩 Problem 91: Reverse Integer (Overall Count: 91 /

150)

📝 Problem Statement
Given a 32-bit signed integer x, return x with its digits reversed.

●​ If reversing x causes the value to go outside the signed 32-bit integer range
[-2³¹, 2³¹ - 1], return 0.​

🔹 Example 1
Input: x = 123
Output: 321

🔹 Example 2
Input: x = -123
Output: -321

🔹 Example 3
Input: x = 120
Output: 21

💡 Intuition
 ●​ Reverse digits using modulo and division:​

○​ digit = x % 10​

○​ x = x / 10​

○​ rev = rev * 10 + digit​

●​ Check for overflow before multiplying by 10:​

○​ rev > Integer.MAX_VALUE / 10 → overflow​

○​ rev < Integer.MIN_VALUE / 10 → underflow​

🧠 Approach
1.​ Initialize rev = 0.​

2.​ While x != 0:​

○​ digit = x % 10​

○​ Check overflow:​

■​ If rev > Integer.MAX_VALUE/10 or rev <

Integer.MIN_VALUE/10, return 0​

○​ rev = rev * 10 + digit​

○​ x /= 10​

3.​ Return rev.​

💻 Java Code (With Comments)

public class ReverseInteger {

public static int reverse(int x) {

int rev = 0;
 while (x != 0) {
int digit = x % 10; // extract last digit

// Check for overflow/underflow

if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE/10 &&
digit > 7))
return 0;
if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE/10 &&
digit < -8))
return 0;

rev = rev * 10 + digit; // append digit

x /= 10; // remove last digit
}

return rev;
}

// Driver code
public static void main(String[] args) {
System.out.println("Reverse 123: " + reverse(123)); // 321
System.out.println("Reverse -123: " + reverse(-123)); // -321
System.out.println("Reverse 120: " + reverse(120)); // 21
System.out.println("Reverse 1534236469: " + reverse(1534236469)); //
0 (overflow)
}
}

🔍 Dry Run Example

Input: x = 123

1.​ rev=0, x=123 → digit=3 → rev=0*10+3=3 → x=12​

2.​ rev=3, x=12 → digit=2 → rev=3*10+2=32 → x=1​

3.​ rev=32, x=1 → digit=1 → rev=32*10+1=321 → x=0 ✅ Output: 321​

📊 Complexity Analysis
Aspec Complexity Explanation
t

Time O(log₁₀n) Number of digits in x

Space O(1) Constant space

⚙️ Edge Cases
Input Output Reason

Overflow 0 Cannot store reversed

integer

Negative Reversed Sign preserved

negative

Trailing zeros Skipped e.g., 120 → 21

🧩 Key Takeaways
●​ Always check for overflow when reversing digits.​

●​ Use modulo/division to process digits.​

●​ Works efficiently in O(log n) time for integer digits.​

TREES

Awesome 🌳 — Let’s start your Trees section strong with:

🧩 Problem 40: Invert Binary Tree (Overall Count: 40 /

150)

📝 Problem Statement
Given the root of a binary tree, invert the tree, and return its root.

👉 Inverting means swapping the left and right subtrees of every node.

🔹 Example 1
Input Tree:

4
/ \
2 7
/\ /\
1 3 6 9

Output Tree (after inversion):

4
/ \
7 2
/\ /\
9 6 3 1

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

💡 Intuition
The problem is asking to mirror the binary tree.

To do this:

●​ For every node, swap its left and right child.​

●​ Then recursively repeat for both subtrees.​

This is a classic example of using recursion (DFS).

🧠 Approach
1.​ If the current node is null, return null.​
 2.​ Recursively invert the left and right subtrees.​

3.​ Swap the left and right child pointers.​

4.​ Return the current node.​

💻 Java Code (With Comments)

/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
public class InvertBinaryTree {

// Recursive DFS approach

public TreeNode invertTree(TreeNode root) {
// Base case: if tree is empty
if (root == null) return null;

// Recursively invert left and right subtrees

TreeNode leftInverted = invertTree(root.left);
TreeNode rightInverted = invertTree(root.right);

// Swap the left and right children

root.left = rightInverted;
root.right = leftInverted;

// Return the root of inverted tree

return root;
}

// Driver code to test the function

public static void main(String[] args) {
 // Example: Build the input tree [4,2,7,1,3,6,9]
TreeNode root = new TreeNode(4);
root.left = new TreeNode(2, new TreeNode(1), new TreeNode(3));
root.right = new TreeNode(7, new TreeNode(6), new TreeNode(9));

InvertBinaryTree obj = new InvertBinaryTree();

TreeNode inverted = obj.invertTree(root);

// Print using BFS to verify

printLevelOrder(inverted);
}

// Helper function to print tree in level order

public static void printLevelOrder(TreeNode root) {
if (root == null) return;
Queue<TreeNode> q = new LinkedList<>();
q.offer(root);
while (!q.isEmpty()) {
TreeNode node = q.poll();
System.out.print(node.val + " ");
if (node.left != null) q.offer(node.left);
if (node.right != null) q.offer(node.right);
}
}
}

🔍 Dry Run Example

Input: [4,2,7,1,3,6,9]

Ste Node Action

p

1 4 Invert left & right subtrees

2 2 Invert (1 ↔ 3)

3 7 Invert (6 ↔ 9)

4 Return up and connect swapped

children

Final Output Tree: [4,7,2,9,6,3,1]

📊 Complexity Analysis
Type Complexity Reason

Time O(N) Every node visited once

Spac O(H) Height of recursion stack (worst-case O(N))

e

🧩 Key Takeaways
●​ Mirrors the structure of the tree.​

●​ Perfect example of recursion and divide & conquer.​

●​ Could also be done iteratively using BFS/queue.​

🌳
👉
Perfect — let’s look at the iterative (BFS) solution for the same problem —​
Invert Binary Tree — but this time using a queue (level-order traversal).

🧩 Problem 40 (Alternate Approach): Invert Binary Tree

— Iterative BFS

💡 Intuition
Instead of recursion (DFS), we can use Breadth-First Search (BFS) to visit nodes level by
level.

At each node:

●​ Swap its left and right children.​

●​ Push the children into the queue for later processing.​

This way, we use a queue instead of recursion, which avoids stack overflow for large trees.
💻 Java Code (Iterative BFS with Comments)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
import java.util.*;

public class InvertBinaryTreeIterative {

public TreeNode invertTree(TreeNode root) {

// Base case: empty tree
if (root == null) return null;

// Use a queue for level-order traversal

Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);

while (!queue.isEmpty()) {
TreeNode current = queue.poll();

// Swap the left and right children

TreeNode temp = current.left;
current.left = current.right;
current.right = temp;

// Add the children to queue for further processing

if (current.left != null) queue.offer(current.left);
if (current.right != null) queue.offer(current.right);
}

return root; // Return the root of inverted tree

}

// Driver code
 public static void main(String[] args) {
// Build input tree [4,2,7,1,3,6,9]
TreeNode root = new TreeNode(4);
root.left = new TreeNode(2, new TreeNode(1), new TreeNode(3));
root.right = new TreeNode(7, new TreeNode(6), new TreeNode(9));

InvertBinaryTreeIterative obj = new InvertBinaryTreeIterative();

TreeNode inverted = obj.invertTree(root);

System.out.print("Inverted Tree (Level Order): ");

printLevelOrder(inverted);
}

// Helper function for level-order printing

public static void printLevelOrder(TreeNode root) {
if (root == null) return;
Queue<TreeNode> q = new LinkedList<>();
q.offer(root);
while (!q.isEmpty()) {
TreeNode node = q.poll();
System.out.print(node.val + " ");
if (node.left != null) q.offer(node.left);
if (node.right != null) q.offer(node.right);
}
}
}

🔍 Dry Run
Input: [4,2,7,1,3,6,9]

Queue Node Swap Result (so far)

Processed Done

[4] 4 2↔7 Root swapped

[7,2] 7 6↔9 Left subtree mirrored

[2,9,6] 2 1↔3 Right subtree mirrored

[9,6,1,3] ... - Tree fully inverted

✅ Output: [4,7,2,9,6,3,1]
📊 Complexity Analysis
Type Complexity Reason

Time O(N) Every node visited once

Spac O(N) Queue holds up to N/2 nodes in last

e level

⚔️ Recursion vs Iteration Comparison

Aspect Recursive DFS Iterative BFS

Implementation Simple, elegant Slightly longer

Space O(H) (stack) O(W) (queue width)

Large Tree May stack overflow Safe

Safety

Preferred When depth is small When tree is wide

✅ Both methods are equally correct — choice depends on tree shape and stack size
limits.

Perfect 🌳 — let’s move on to the next tree problem in your NeetCode 150 journey!

🧩 Problem 41: Maximum Depth of Binary Tree (Overall

Count: 41 / 150)

📝 Problem Statement
Given the root of a binary tree, return the maximum depth of the tree.

●​ The maximum depth is the number of nodes along the longest path from the root
node down to the furthest leaf node.​
🔹 Example 1
Input Tree:

3
/ \
9 20
/ \
15 7

Output:

Explanation:

●​ Longest path = 3 → 20 → 7​

●​ Number of nodes = 3​

💡 Intuition
This is one of the simplest and most classic recursion-based tree problems.

We can solve it with the logic:

“The depth of a node = 1 + max(depth of left subtree, depth of right subtree)”

We perform DFS traversal recursively, counting the height at each step.

🧠 Approach
1.​ Base Case:​
If root == null, return 0. (No tree → depth 0)​

2.​ Recursive Case:​

○​ Compute the depth of the left subtree​

○​ Compute the depth of the right subtree​

 ○​ Return 1 + max(leftDepth, rightDepth)​

💻 Java Code (Recursive DFS — With Comments)

/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/

public class MaximumDepthOfBinaryTree {

// Recursive DFS solution

public int maxDepth(TreeNode root) {
// Base case: Empty tree
if (root == null) return 0;

// Recursively find the depth of left and right subtrees

int leftDepth = maxDepth(root.left);
int rightDepth = maxDepth(root.right);

// Add 1 (for the current root node)

return 1 + Math.max(leftDepth, rightDepth);
}

// Driver code to test the function

public static void main(String[] args) {
// Build tree: [3,9,20,null,null,15,7]
TreeNode root = new TreeNode(3);
root.left = new TreeNode(9);
root.right = new TreeNode(20, new TreeNode(15), new TreeNode(7));

MaximumDepthOfBinaryTree obj = new MaximumDepthOfBinaryTree();

 System.out.println("Maximum Depth: " + obj.maxDepth(root)); //
Output: 3
}
}

🔍 Dry Run
Input:

3
/ \
9 20
/ \
15 7

Node Left Depth Right Depth Return

15 0 0 1

7 0 0 1

20 1 1 2

9 0 0 1

3 1 2 3

✅ Output → 3

📊 Complexity Analysis
Type Complexit Explanation
y

Time O(N) Each node visited once

Spac O(H) Height of tree due to recursion stack (O(N) worst-case, O(log N)
e balanced)

⚡ Alternative BFS (Iterative) Approach

You can also use Level Order Traversal (BFS) to find depth iteratively:
public int maxDepthBFS(TreeNode root) {
if (root == null) return 0;
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
int depth = 0;

while (!queue.isEmpty()) {
int size = queue.size(); // nodes in current level
for (int i = 0; i < size; i++) {
TreeNode node = queue.poll();
if (node.left != null) queue.offer(node.left);
if (node.right != null) queue.offer(node.right);
}
depth++; // completed one level
}

return depth;
}

✅ Works level-by-level → Increment depth after each level.

🧩 Key Takeaways
●​ Classic recursion + divide & conquer problem.​

●​ Simple pattern used in many tree problems (height, diameter, balance checks).​

●​ BFS alternative helps avoid recursion stack overflow.​

Great! Let's continue with the next Tree problem ✅

🌳 Problem 42 / 150: Diameter of Binary Tree

📝 Problem Statement
Given the root of a binary tree, return the diameter of the tree.
📌 The diameter is the longest path between any two nodes in a tree.​
This path may or may not pass through the root.

⚠️ Diameter is measured in number of edges, not nodes.

🔹 Example
Input Tree:
1
/ \
2 3
/\
4 5

✅ Longest path = 4 → 2 → 1 → 3​
✅ Number of edges = 3​
➡ Output: 3

💡 Intuition
At each node:

●​ Longest path through that node =​

height(left subtree) + height(right subtree)​

So we compute height while updating a global variable diameter.

This uses DFS + postorder traversal ✅

✅ Approach
1.​ Create a global variable to store maximum diameter found so far.​

2.​ DFS to compute depth of left and right subtree recursively.​

3.​ Update diameter = max(diameter, leftDepth + rightDepth)​

4.​ Return 1 + max(leftDepth, rightDepth) (for height)​

✅ Java Code with Full Comments + Driver Code
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/

public class DiameterOfBinaryTree {

private int diameter = 0; // To store the maximum diameter result

public int diameterOfBinaryTree(TreeNode root) {

dfs(root); // Call DFS to compute heights and diameter
return diameter;
}

private int dfs(TreeNode node) {

if (node == null) return 0; // Base case: height of null = 0

// Recursively compute height of left and right subtrees

int leftHeight = dfs(node.left);
int rightHeight = dfs(node.right);

// Update diameter if current path is longer

diameter = Math.max(diameter, leftHeight + rightHeight);

// Return height including current node

return 1 + Math.max(leftHeight, rightHeight);
}

// Driver code for testing

public static void main(String[] args) {
// Build tree: [1,2,3,4,5]
 TreeNode root = new TreeNode(1);
root.left = new TreeNode(2, new TreeNode(4), new TreeNode(5));
root.right = new TreeNode(3);

DiameterOfBinaryTree obj = new DiameterOfBinaryTree();

System.out.println("Diameter: " + obj.diameterOfBinaryTree(root));
// Output: 3
}
}

🔍 Dry Run (Step-by-step)

Tree:

1
/ \
2 3
/\
4 5

Node Left Height Right Height Update Diameter Return Height

4 0 0 0 1

5 0 0 0 1

2 1 1 2 2

3 0 0 2 1

1 2 1 3 ✅ 3

📌 Final answer = 3 edges

⏱️ Complexity Analysis
Complexit Value Reason
y

Time O(N) Visit each node once

Space O(H) Recursion stack (H=tree height) → O(N) worst case, O(logN)
balanced
✅ Key Takeaway
Operation Use Case

Height = 1 + max(left, returned from DFS

right)

Diameter = left + right updated globally

📌 This is a common pattern used for tree diameter, longest path, and balanced tree checks.
Perfect! Moving ahead ✅

🌳 Problem 43 / 150: Balanced Binary Tree

📝 Problem Statement
Given a binary tree, determine if it is height-balanced.

A binary tree is balanced if:

For every node →​

|height(left subtree) - height(right subtree)| ≤ 1

🔹 Example
✅ Balanced Tree:
3

/\

9 20

/ \

15 7

Output → true
❌ Not Balanced Tree:
1

Output → false

💡 Intuition
We compute:

●​ Height — same as previous problem​

●​ If any subtree becomes unbalanced → bubble up failure​

❌ Avoid repeated height computation (O(N²) naive approach)

✅ Instead return height if balanced​
⛔ return -1 if unbalanced (early exit!)

✅ Approach
Define a helper function:

●​ Returns height if subtree is balanced​

●​ Returns -1 if subtree is unbalanced​

If root result is -1 → tree not balanced​

Else → balanced ✅

✅ Java Code with Comments + Driver Code

/**

* Definition for a binary tree node.

* public class TreeNode {

* int val;

* TreeNode left;

* TreeNode right;

* TreeNode() {}

* TreeNode(int val) { this.val = val; }

* TreeNode(int val, TreeNode left, TreeNode right) {

* this.val = val;

* this.left = left;

* this.right = right;

* }

* }

*/

public class BalancedBinaryTree {

public boolean isBalanced(TreeNode root) {

// If dfs returns -1 → not balanced

return dfs(root) != -1;

private int dfs(TreeNode node) {

if (node == null) return 0; // Height of null = 0

 // Recursively get left and right heights

int left = dfs(node.left);

int right = dfs(node.right);

// If already unbalanced below → propagate

if (left == -1 || right == -1) return -1;

// If difference > 1 → unbalanced

if (Math.abs(left - right) > 1) return -1;

// Return height including current node

return 1 + Math.max(left, right);

// Driver Code for testing

public static void main(String[] args) {

// Balanced tree

TreeNode root = new TreeNode(3);

root.left = new TreeNode(9);

root.right = new TreeNode(20, new TreeNode(15), new TreeNode(7));

BalancedBinaryTree obj = new BalancedBinaryTree();

System.out.println("Is Balanced: " + obj.isBalanced(root));

// Output: true

}
🔍 Dry Run
Balanced tree:

/\

9 20

/ \

15 7

Node Left Height Right Height Balanced Return

?

15, 7, 9 0 0 ✅ 1

20 1 1 ✅ 2

3 1 2 ✅ 3

📌 Returns height 3 → Balanced ✅

⏱️ Complexity Analysis
Complexity Value

Time O(N)

Space O(H)
📌 Early exit ensures best efficiency ✅

✅ Key Points
Concept Use

Return height If valid subtree

Return -1 If imbalance detected

DFS Natural for bottom-up calculations

(postorder)

Great! Let's move to the next one ✅

🌳 Problem 44 / 150: Same Tree

📝 Problem Statement
Given the roots of two binary trees p and q, return true if the two trees are:

✔️ Structurally identical​
✔️ Have the exact same node values
Otherwise, return false.

🔹 Example
✅ Example 1
Tree p: 1
 /\

2 3

Tree q: 1

/\

2 3

Output: true

❌ Example 2
Tree p: 1

Tree q: 1

Output: false

💡 Intuition
We need to recursively check:

1️⃣ Both nodes must exist​

2️⃣ Both must have same value​
3️⃣ Their left and right subtrees must match

📌 This is a simple DFS comparison problem

✅ Approach
Use recursion:

●​ If both nodes are null → equal ✅​

●​ If only one is null → not equal ❌​

●​ If values mismatch → not equal ❌​

●​ Recursively check left & right children​

✅ Java Code with Comments + Driver Code

/**

* Definition for a binary tree node.

* public class TreeNode {

* int val;

* TreeNode left;

* TreeNode right;

* TreeNode() {}

* TreeNode(int val) { this.val = val; }

* TreeNode(int val, TreeNode left, TreeNode right) {

* this.val = val;

* this.left = left;

* this.right = right;

* }

* }

*/
public class SameTree {

public boolean isSameTree(TreeNode p, TreeNode q) {

// If both nodes are null → trees match at this point

if (p == null && q == null) return true;

// If one is null or values differ → not same tree

if (p == null || q == null || p.val != q.val) return false;

// Recursively compare left and right subtree

return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);

// Driver code to test

public static void main(String[] args) {

TreeNode p = new TreeNode(1);

p.left = new TreeNode(2);

p.right = new TreeNode(3);

TreeNode q = new TreeNode(1);

q.left = new TreeNode(2);

q.right = new TreeNode(3);

SameTree obj = new SameTree();

System.out.println("Are Both Same: " + obj.isSameTree(p, q));

// Output: true
 }

🔍 Dry Run
Compare:

p:1 q:1

✔️ equal → check children​

Left subtree -> 2 == 2 ✅​
Right subtree -> 3 == 3 ✅​
All match → return true ✅

⏱️ Complexity Analysis
Complexity Value

Time O(N)

Space O(H)

H = height of tree (worst O(N), best O(logN))

✅ Key Takeaway
Check Meaning

Both null Same ✅

 One null Not same ❌
Values differ Not same ❌
Recursively check children Must match ✅

Awesome! Continuing ✅

🌳 Problem 45 / 150: Subtree of Another Tree

📝 Problem Statement
You are given two binary trees: root and subRoot.

Return true if subRoot is a subtree of root.​

Otherwise return false.

📌 Definition: A subtree must match both structure & node values exactly.

🔹 Example
✅ Example 1
root: 3

/\

4 5

/\

1 2

subRoot: 4
 /\

1 2

Output: true

❌ Example 2
root: 3

/\

4 5

/\

1 2

subRoot: 4

/\

1 2

Output: false (extra node 0 causes mismatch)

💡 Intuition
This problem uses the previous function Same Tree ✔️
Steps:

1.​ Traverse root tree​

 2.​ Every time you find a node with the same value as subRoot.val → check if both
trees are identical​

3.​ If any match found → true​

✅ Approach
●​ DFS original tree​

●​ For each node -> call isSameTree(rootNode, subRootNode)​

●​ If ever true → return true​

✅ Java Code with Comments + Driver Code

/**

* Definition for a binary tree node.

* public class TreeNode {

* int val;

* TreeNode left;

* TreeNode right;

* TreeNode() {}

* TreeNode(int val) { this.val = val; }

* TreeNode(int val, TreeNode left, TreeNode right) {

* this.val = val;

* this.left = left;

* this.right = right;

* }

* }
*/

public class SubtreeOfAnotherTree {

public boolean isSubtree(TreeNode root, TreeNode subRoot) {

// If subRoot is null → empty tree always subtree

if (subRoot == null) return true;

// If root is null → can't match a non-null subtree

if (root == null) return false;

// Check if trees match at current node OR search left/right subtree

if (isSame(root, subRoot)) return true;

return isSubtree(root.left, subRoot) || isSubtree(root.right,

subRoot);

// Check if two trees are identical

private boolean isSame(TreeNode a, TreeNode b) {

if (a == null && b == null) return true;

if (a == null || b == null || a.val != b.val) return false;

return isSame(a.left, b.left) && isSame(a.right, b.right);

}
 // Driver Code

public static void main(String[] args) {

TreeNode root = new TreeNode(3);

root.left = new TreeNode(4, new TreeNode(1), new TreeNode(2));

root.right = new TreeNode(5);

TreeNode subRoot = new TreeNode(4, new TreeNode(1), new TreeNode(2));

SubtreeOfAnotherTree obj = new SubtreeOfAnotherTree();

System.out.println("Is Subtree: " + obj.isSubtree(root, subRoot));

// Output: true

🔍 Dry Run
root: 3 → not same → check children

↓ (left)

4 → same root value → compare whole subtree ✅ match found

Return true ✅

⏱️ Complexity Analysis
Let:

●​ N = number of nodes in root​

●​ M = number of nodes in subRoot​

 Complexity Value Reason

Time O(N × M) In worst case check identical for every

node

Space O(H) Recursion depth

Not optimal but acceptable for LeetCode constraints ✅

✅ Key Takeaways
Feature Insight

Tree match Reuses "Same Tree" logic

check

Return early As soon as match found

DFS traversal Ensures entire root

searched

Great ✅​
Now that Binary Tree Traversals are completed, we’ll move to the next important concept:

✅ Tree Concepts You MUST Know for Interviews

1️⃣ Height / Depth / Level of a Tree

●​ Height of a node = Max edges from that node to a leaf​

 ●​ Depth of a node = Number of edges from root to that node​

●​ Level of a node = Depth + 1​

●​ Height of tree = Height of root​

Important Question​
✔ Compute height of a tree (recursive)

2️⃣ Diameter of a Binary Tree

🧠 Longest path between any two nodes​

✅ Not necessarily through root
Optimized Solution​
→ Use DFS and compute height while updating max diameter

3️⃣ Balanced Binary Tree

🔹
✔ Height difference between left & right subtree ≤ 1​
Check height & balance in ONE recursion

4️⃣ Identical Trees

→ Compare root, left, right recursively

5️⃣ Invert Binary Tree

✅
→ Swap left & right recursively​
Famous Google interview question

6️⃣ Lowest Common Ancestor (LCA)

●​ In Binary Tree​

●​ In Binary Search Tree (use BST properties → faster)​

7️⃣ Binary Search Tree (BST)

Properties:

●​ left < root < right​

●​ Inorder traversal → sorted order ✅​

Common Problems:

●​ Search in BST​

●​ Insert Node​

●​ Delete Node​

●​ Validate if a tree is BST​

8️⃣ Tree Construction

👉 Very Important in Interviews

You will construct trees using:

●​ Inorder + Preorder​

●​ Inorder + Postorder​

9️⃣ Vertical Order / Top View / Bottom View

All based on HD (Horizontal Distance) concept​

Used BFS + HashMap

🔥 Most Asked Tree Interview Questions (Must Do ✅)

Topic Problem
 Height Max Depth of Binary Tree

Diameter Diameter of Binary Tree

Balanced Check Balanced Tree

Equality Identical Trees

LCA LCA in BT + BST

BST Ops Search, Insert, Delete

Views Top & Bottom View

Traversal Zig-zag Level Order

Reversal

Construction Tree from Traversals

Lowest Common Ancestor of a Binary

Search Tree
Problem statement
Given the root of a binary search tree (BST) and two nodes p and q in the tree, return their
lowest common ancestor (LCA).

The lowest common ancestor of two nodes p and q is defined as the lowest node in T that
has both p and q as descendants (a node can be a descendant of itself).
You may assume:

●​ All TreeNode.val are unique.​

●​ p and q are different and both exist in the BST.​

Signature (Java):

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q)

TreeNode definition:

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode(int x) { val = x; }

Examples
Example 1

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8

Output: 6

Explanation: The LCA of nodes 2 and 8 is 6.

Example 2

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4

Output: 2

Explanation: Node 2 is an ancestor of node 4, so LCA is 2 (a node can be ancestor of itself).

Intuition (short)
Because this is a BST, for any node node:

●​ all keys in node.left < node.val​

●​ all keys in node.right > node.val​

So if both p.val and q.val are less than node.val, LCA lies in the left subtree.​
If both are greater, LCA lies in the right subtree.​
Otherwise (they split across node or one equals node), node is the LCA.

This leads to a simple O(h) algorithm where h = tree height.

Approach (step-by-step)
1.​ Ensure p.val <= q.val (optional — makes comparisons easier). Not required but
sometimes simplifies reasoning.​

2.​ Start at root.​

3.​ While root is not null:​

○​ If p.val and q.val are both less than root.val, move root =
root.left.​

○​ Else if both are greater than root.val, move root = root.right.​

○​ Else (they lie on different sides of root, or one equals root), root is the
LCA — return it.​

4.​ If the loop finishes without finding (shouldn't happen per assumptions), return null.​

You can implement this iteratively (no recursion stack) or recursively (natural and concise).
I'll give both (primary: iterative) and comment code well.
Java code (iterative) with comments
/**

* Definition for a binary tree node.

* public class TreeNode {

* int val;

* TreeNode left;

* TreeNode right;

* TreeNode(int x) { val = x; }

* }

*/

public class Solution {

/**

* Iterative approach using BST properties.

* Time: O(h) where h is height of tree

* Space: O(1) extra (excluding input)

*/

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode

q) {

// Ensure p.val <= q.val (not required but makes comparisons

intuitive)

int pv = p.val;

int qv = q.val;

if (pv > qv) {

int tmp = pv; pv = qv; qv = tmp;

}
 TreeNode node = root;

while (node != null) {

if (qv < node.val) {

// Both p and q are in left subtree

node = node.left;

} else if (pv > node.val) {

// Both p and q are in right subtree

node = node.right;

} else {

// They split here or one equals node -> node is LCA

return node;

return null; // should not occur if p and q are in the tree

Recursive version (alternate)

public class Solution {

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode

q) {

if (root == null) return null;

if (p.val < root.val && q.val < root.val) {

return lowestCommonAncestor(root.left, p, q);

} else if (p.val > root.val && q.val > root.val) {

return lowestCommonAncestor(root.right, p, q);

 } else {

return root; // split point

Dry run (step-by-step) — Example 1

Tree (values only):

/ \

2 8

/\ /\

0 4 7 9

/\

3 5

Find LCA for p=2, q=8.

Start: node = 6.

●​ p.val = 2, q.val = 8.​

●​ Is q < node.val? 8 < 6 → no.​

●​ Is p > node.val? 2 > 6 → no.​

●​ Else → split across 6 (one in left, one in right). Return 6. Done.​

Example 2: p=2, q=4.​

Start: node = 6.
 ●​ Both p and q < 6 → move left: node = 2.​
At node 2:​

●​ p=2, q=4. Is q < 2? No. Is p > 2? No (p == node). Else → return 2. Done.​

Time Complexity
●​ Time: O(h) where h = height of the BST. In balanced BST, h = O(log n). In
worst-case skewed BST, h = O(n).​

●​ Space:​

○​ Iterative version: O(1) extra space.​

○​ Recursive version: O(h) space due to recursion call stack.​

Notes & edge-cases

●​ Works because it's a BST; do not use the same approach on an arbitrary binary tree.​

●​ If nodes may not exist in the tree, you should verify presence first (not required here).​

●​ If p or q equals root at any point, root may be the LCA — the algorithm correctly
handles that.​

Perfect👍 ​
Let’s move to the next problem on your list:

🏷️ Binary Tree Level Order Traversal

🧩 Problem Statement
Given the root of a binary tree, return the level order traversal of its nodes' values — that
is, visit nodes level by level from left to right.

In simpler words:

●​ You need to print (or return) all nodes on level 1,​

●​ then level 2,​

●​ then level 3, and so on.​

Function Signature (Java)

public List<List<Integer>> levelOrder(TreeNode root)

TreeNode Definition

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode() {}

TreeNode(int val) { this.val = val; }

TreeNode(int val, TreeNode left, TreeNode right) {

this.val = val;

this.left = left;

this.right = right;

🧠 Intuition
This problem is a Breadth-First Search (BFS) problem.

●​ BFS explores the tree level by level.​

●​ We can use a queue to store nodes for each level.​

●​ For each level:​

1.​ Process all nodes currently in the queue.​

2.​ Add their children to the queue (for next level).​

3.​ Store the list of current level’s values.​

⚙️ Approach (Step-by-Step)
1.​ If root is null, return an empty list.​

2.​ Initialize a queue and add root to it.​

3.​ While the queue is not empty:​

○​ Create a list level to store values of the current level.​

○​ Find the size of the queue → number of nodes at current level.​

○​ Loop size times:​

■​ Pop a node from the queue.​

■​ Add its value to level.​

■​ If it has left child → add to queue.​

■​ If it has right child → add to queue.​

○​ Add the level list to the result list.​

4.​ Return result.​

💻 Java Code (with comments)
import java.util.*;

public class Solution {

public List<List<Integer>> levelOrder(TreeNode root) {

List<List<Integer>> result = new ArrayList<>();

if (root == null) return result; // Edge case: empty tree

Queue<TreeNode> queue = new LinkedList<>();

queue.offer(root); // Start BFS from root

while (!queue.isEmpty()) {

int size = queue.size(); // Number of nodes at current level

List<Integer> level = new ArrayList<>();

// Process all nodes in this level

for (int i = 0; i < size; i++) {

TreeNode current = queue.poll();

level.add(current.val);

// Add children for next level

if (current.left != null) queue.offer(current.left);

if (current.right != null) queue.offer(current.right);

}
 result.add(level); // Add this level to final result

return result;

🧾 Example
Input:

/\

9 20

/\

15 7

Output:

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

🔍 Dry Run (Step-by-Step)

Tree:

/\

9 20

/\
 15 7

Initial State:

queue = [3]

result = []

Level 1:

●​ size = 1​

●​ Take node 3 → add 9 and 20 to queue​

●​ level = [3]​

queue = [9, 20]

result = [[3]]

Level 2:

●​ size = 2​

●​ Pop 9 → no children​

●​ Pop 20 → add 15 and 7 to queue​

●​ level = [9, 20]​

queue = [15, 7]

result = [[3], [9, 20]]

Level 3:

●​ size = 2​

●​ Pop 15 → no children​
 ●​ Pop 7 → no children​

●​ level = [15, 7]​

queue = []

result = [[3], [9, 20], [15, 7]]

Queue empty → Done ✅

⏱️ Time & Space Complexity

Complexity Description

Time O(N) – Each node is enqueued and dequeued once

Space O(N) – Queue can hold up to N/2 nodes (worst case, last
level)

✅ Key Takeaways
●​ This is a classic BFS traversal problem.​

●​ Queue is ideal for level-wise processing.​

●​ Each level’s values are collected before moving to the next.​

Awesome ​😎
Let’s move to the next one:
🏷️ Binary Tree Right Side View
🧩 Problem Statement
Given the root of a binary tree, imagine standing on the right side of it.​
Return the list of the node values you can see from top to bottom.

Function Signature (Java)

public List<Integer> rightSideView(TreeNode root)

Definition for TreeNode

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode() {}

TreeNode(int val) { this.val = val; }

TreeNode(int val, TreeNode left, TreeNode right) {

this.val = val;

this.left = left;

this.right = right;

🧠 Intuition
If you look at a binary tree from the right side:
 ●​ For each level, you only see the rightmost node.​

That means:

●​ We can perform a level order traversal (BFS).​

●​ For each level, take the last node we encounter — that’s visible from the right side.​

Alternatively, we can use DFS (right-first traversal):

●​ Traverse the tree in Root → Right → Left order.​

●​ Keep track of the first node visited at each depth — it’s the rightmost one at that
level.​

We'll use the BFS approach first (intuitive and similar to the previous problem).

⚙️ Approach (BFS / Level Order)

1.​ If root is null, return an empty list.​

2.​ Use a queue to perform level order traversal.​

3.​ For each level:​

○​ Track the number of nodes (size).​

○​ Process each node.​

○​ When you reach the last node of that level, add its value to result.​

4.​ Return the list after traversal.​

💻 Java Code (with comments)

import java.util.*;

public class Solution {

 public List<Integer> rightSideView(TreeNode root) {

List<Integer> result = new ArrayList<>();

if (root == null) return result;

Queue<TreeNode> queue = new LinkedList<>();

queue.offer(root);

while (!queue.isEmpty()) {

int size = queue.size();

// Loop through one level

for (int i = 0; i < size; i++) {

TreeNode node = queue.poll();

// If this is the last node in the current level, add it to

result

if (i == size - 1) {

result.add(node.val);

// Add children for next level

if (node.left != null) queue.offer(node.left);

if (node.right != null) queue.offer(node.right);

return result;
 }

🧾 Example
Input:

/\

2 3

\ \

5 4

Output:

[1, 3, 4]

🔍 Dry Run (Step-by-Step)

Tree:

/\

2 3

\ \

5 4

Initial:

queue = [1]
result = []

Level 1:

●​ size = 1​

●​ Pop 1 → last node at this level → add 1​

●​ Add children: 2, 3​

queue = [2, 3]

result = [1]

Level 2:

●​ size = 2​

●​ Pop 2 → not last → skip adding​

●​ Pop 3 → last node → add 3​

●​ Add children: (2.right=5), (3.right=4)​

queue = [5, 4]

result = [1, 3]

Level 3:

●​ size = 2​

●​ Pop 5 → not last → skip​

●​ Pop 4 → last → add 4​

queue = []

result = [1, 3, 4]
✅ Done

⏱️ Time & Space Complexity

Complexity Description

Time O(N) → each node processed once

Space O(N) → queue can hold up to N/2 nodes (worst

case)

⚡ Alternative (DFS – Right First)

A recursive approach that visits right child first and keeps track of depth:

public class Solution {

public List<Integer> rightSideView(TreeNode root) {

List<Integer> result = new ArrayList<>();

dfs(root, 0, result);

return result;

private void dfs(TreeNode node, int depth, List<Integer> result) {

if (node == null) return;

// If visiting this depth for the first time, add node value

if (depth == result.size()) {

result.add(node.val);
 }

// Visit right first, then left

dfs(node.right, depth + 1, result);

dfs(node.left, depth + 1, result);

✅ Same output, slightly more elegant, but uses recursion (O(h) stack).

✅ Key Takeaways
●​ BFS → easy to understand, good for level-based logic.​

●​ DFS (right-first) → elegant, shorter code.​

●​ The last (or first rightmost) node per level forms the right side view.​

Perfect 😄 ​
Let’s go to the next problem in your list:

🏷️ Count Good Nodes in Binary Tree

🧩 Problem Statement
Given the root of a binary tree, a node X in the tree is called a good node if:
 On the path from the root to X, there are no nodes with a value greater than
X.val.

Return the number of good nodes in the tree.

Function Signature (Java)

public int goodNodes(TreeNode root)

Definition for TreeNode

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode() {}

TreeNode(int val) { this.val = val; }

TreeNode(int val, TreeNode left, TreeNode right) {

this.val = val;

this.left = left;

this.right = right;

🧠 Intuition
As we move from the root to leaves, we can track the maximum value seen so far on that
path.

●​ A node is good if node.val >= maxSoFar.​

 ●​ Then we continue recursively for left and right children,​
passing the updated maxSoFar (max(maxSoFar, node.val)).​

This is a Depth-First Search (DFS) traversal with a simple condition check.

⚙️ Approach (DFS – Recursive)

1.​ Start from the root with initial maxSoFar = root.val.​

2.​ For each node:​

○​ If node.val >= maxSoFar, it’s a “good node”.​

○​ Recur for its left and right subtrees with updated max value.​

3.​ Sum up all good nodes found.​

💻 Java Code (with comments)

public class Solution {

public int goodNodes(TreeNode root) {

// Start DFS from root with its own value as initial max

return dfs(root, root.val);

// Helper DFS function

private int dfs(TreeNode node, int maxSoFar) {

if (node == null) return 0;

// Check if current node is good

int good = (node.val >= maxSoFar) ? 1 : 0;

 // Update the maximum value along this path

maxSoFar = Math.max(maxSoFar, node.val);

// Recurse for left and right subtrees

good += dfs(node.left, maxSoFar);

good += dfs(node.right, maxSoFar);

return good;

🧾 Example
Input:

/\

1 4

/ /\

3 1 5

Output:

Explanation:

●​ Path 3 → 1 → 3 → nodes 3 and 3 are good.​

 ●​ Path 3 → 4 → 5 → nodes 3, 4, 5 are good.​
Total = 4 good nodes.​

🔍 Dry Run (Step-by-Step)

Tree:

/\

1 4

/ /\

3 1 5

Start:​
dfs(root=3, max=3)​
3 >= 3 → good = 1

Left Subtree:

dfs(1, max=3)​
1 < 3 → not good

●​ Left child: dfs(3, max=3) → 3 >= 3 → good = 1​

●​ Right child: null → 0​

Left subtree total = 1​

Right Subtree:

dfs(4, max=3) → 4 >= 3 → good = 1

●​ Left: dfs(1, max=4) → 1 < 4 → not good​

●​ Right: dfs(5, max=4) → 5 >= 4 → good = 1​

Right subtree total = 2​
✅ Total = 1 (root) + 1 (left) + 2 (right) = 4

⏱️ Time & Space Complexity

Complexity Description

Time O(N) → Each node visited once

Space O(H) → Recursion stack (H = height of

tree)

Best case (balanced O(log N) stack

tree)

Worst case (skewed O(N) stack

tree)

✅ Key Takeaways
●​ Each node’s goodness depends only on the path from root → node.​

●​ DFS traversal naturally keeps track of this path info.​

●​ Easy recursive pattern: “carry info down, accumulate result up”.​

Excellent 👍​
Let’s move on to the next problem in your list:

🏷️ Validate Binary Search Tree (BST)

🧩 Problem Statement
Given the root of a binary tree, determine if it is a valid binary search tree (BST).

A valid BST is defined as:

●​ The left subtree of a node contains only nodes with keys less than the node’s
key.​

●​ The right subtree contains only nodes with keys greater than the node’s key.​

●​ Both the left and right subtrees must also be BSTs.​

Function Signature (Java)

public boolean isValidBST(TreeNode root)

Definition for TreeNode

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode() {}

TreeNode(int val) { this.val = val; }

TreeNode(int val, TreeNode left, TreeNode right) {

this.val = val;

this.left = left;

this.right = right;

}
🧠 Intuition
The key property of BSTs:

Inorder traversal (Left → Root → Right) of a BST produces a strictly

increasing sequence.

We can validate a BST in two main ways:

1.​ Inorder traversal method:​

○​ Do an inorder traversal.​

○​ If we ever find a current node’s value ≤ previous node’s value → not a BST.​

2.​ Range (min–max) method:​

○​ For each node, ensure its value is within a valid range:​

■​ Left child range: (min, node.val)​

■​ Right child range: (node.val, max)​

We'll use the range method, as it’s more fundamental and elegant.

⚙️ Approach (Recursive – Using Min/Max Bounds)

1.​ Start from the root with the range (-∞, +∞).​

2.​ For each node:​

○​ If its value is not in (min, max), return false.​

○​ Recur for left subtree with updated range (min, node.val).​

○​ Recur for right subtree with updated range (node.val, max).​

3.​ If all nodes satisfy the property, return true.​

💻 Java Code (with comments)
public class Solution {

public boolean isValidBST(TreeNode root) {

// Use helper function with min and max boundaries

return validate(root, Long.MIN_VALUE, Long.MAX_VALUE);

private boolean validate(TreeNode node, long min, long max) {

// Base case: empty subtree is valid

if (node == null) return true;

// Current node must be within (min, max)

if (node.val <= min || node.val >= max) return false;

// Recursively validate left and right subtrees

return validate(node.left, min, node.val) &&

validate(node.right, node.val, max);

✅ Note:​
We use long for min/max to safely handle integer edge cases (since node values are ints).

🧾 Example
Input:

/\

1 3

Output:

true

✅
Explanation:​
Inorder = [1, 2, 3] → strictly increasing

Input 2:

/\

1 4

/\

3 6

Output:

false

❌
Explanation:​
Node 3 is in the right subtree of 5 but 3 < 5 → violates BST rule

🔍 Dry Run (Step-by-Step)

Tree:

5
 /\

1 4

/\

3 6

Start:​
validate(5, -∞, +∞) → 5 is valid.​
→ Check left (min=-∞, max=5)​
→ Check right (min=5, max=+∞)

Left Subtree

validate(1, -∞, 5) → 1 valid, left/right null → ✅

Right Subtree

validate(4, 5, +∞) → 4 ≤ 5 ❌ → invalid.

Hence, return false.

⏱️ Time & Space Complexity

Complexity Description

Time O(N) → Each node visited once

Space O(H) → Recursion stack (H = height of

tree)

Best case O(log N)

(balanced)
 Worst case O(N)
(skewed)

✅ Key Takeaways
●​ Use min/max range tracking to validate BST recursively.​

●​ Inorder traversal can also be used but requires tracking previous node.​

●​ Always handle integer overflow using long.​

Perfect 👌 ​
Let’s go to the next problem in your list:

🏷️ Kth Smallest Element in a BST

🧩 Problem Statement
Given the root of a binary search tree (BST) and an integer k,​
return the kᵗʰ smallest value (1-indexed) among all the nodes in the tree.

Function Signature (Java)

public int kthSmallest(TreeNode root, int k)

TreeNode Definition

public class TreeNode {

int val;
 TreeNode left;

TreeNode right;

TreeNode() {}

TreeNode(int val) { this.val = val; }

TreeNode(int val, TreeNode left, TreeNode right) {

this.val = val;

this.left = left;

this.right = right;

🧠 Intuition
For a BST, the inorder traversal (Left → Node → Right)​
visits nodes in sorted ascending order.

So:

●​ Perform an inorder traversal.​

●​ Keep a counter of how many nodes we’ve visited.​

●​ When the counter = k, we’ve found the kᵗʰ smallest element.​

⚙️ Approach (Iterative or Recursive Inorder)

✅ Steps:
1.​ Start from root.​

2.​ Perform inorder traversal:​

 ○​ Traverse left subtree.​

○​ Visit node → increment counter.​

○​ When counter == k → return node’s value.​

○​ Traverse right subtree.​

3.​ Stop traversal once found (to avoid unnecessary work).​

We’ll use iterative inorder (stack-based) for clarity.

💻 Java Code (Iterative – With Comments)

import java.util.*;

public class Solution {

public int kthSmallest(TreeNode root, int k) {

Stack<TreeNode> stack = new Stack<>();

TreeNode current = root;

int count = 0;

// Inorder traversal using stack

while (current != null || !stack.isEmpty()) {

// Go as left as possible

while (current != null) {

stack.push(current);

current = current.left;

}
 // Visit the node

current = stack.pop();

count++;

// If it's the kth element, return its value

if (count == k) return current.val;

// Move to right subtree

current = current.right;

return -1; // Shouldn't reach here if k is valid

🧾 Example
Input:

/\

1 4

k=1

Output:
1

Input 2:

/\

3 6

/\

2 4

k=3

Output:

🔍 Dry Run (Step-by-Step)

Tree:

/\

3 6

/\

2 4

1
k=3

Inorder order: [1, 2, 3, 4, 5, 6]

Traversal process:

Ste Stack Current Count Output

p

1 [5, 3, 2, 1] null 0 -

2 pop(1) → count=1 1 1 -

3 move right (null) - 1 -

4 pop(2) → count=2 2 2 -

5 pop(3) → count=3 3 3 ✅ return 3

⏱️ Time & Space Complexity

Complexity Description

Time O(H + k) — where H = tree height, since we only traverse part of

tree

Space O(H) — stack space (inorder traversal stack)

 For balanced O(log N + k)
BST

For skewed BST O(N)

🧩 Extra Notes
●​ For frequent queries, augment BST nodes with subtree counts to find kᵗʰ smallest
in O(log N).​

●​ But for one-time queries, the simple inorder method is best.​

✅ Key Takeaways
●​ Inorder traversal gives elements in sorted order.​

●​ Use a counter to find the kᵗʰ element.​

●​ Efficient, clear, and uses BST properties directly.​

Awesome 😎 ​
Let’s move on to the next one in your list:

🏷️ Construct Binary Tree from Preorder

and Inorder Traversal

🧩 Problem Statement
Given two integer arrays preorder and inorder, where:

●​ preorder is the preorder traversal of a binary tree,​

●​ inorder is the inorder traversal of the same tree,​

construct and return the binary tree.

Function Signature (Java)

public TreeNode buildTree(int[] preorder, int[] inorder)

Definition for TreeNode

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode() {}

TreeNode(int val) { this.val = val; }

TreeNode(int val, TreeNode left, TreeNode right) {

this.val = val;

this.left = left;

this.right = right;

🧠 Intuition
To reconstruct the tree, recall:
 ●​ Preorder traversal: Root → Left → Right​

●​ Inorder traversal: Left → Root → Right​

So:

1.​ The first element in preorder is always the root.​

2.​ In inorder, all elements before the root belong to the left subtree,​
and all elements after the root belong to the right subtree.​

3.​ Recursively apply this logic to build left and right subtrees.​

⚙️ Approach (Recursive)
1.​ Create a hash map for quick lookup of any node’s index in the inorder array.​

2.​ Maintain a global index (or pointer) in preorder to track which node to create next.​

3.​ Recursively:​

○​ Pick current root from preorder.​

○​ Find its index in inorder using the map.​

○​ Recur for left and right subtrees using the inorder index boundaries.​

💻 Java Code (with comments)

import java.util.*;

public class Solution {

private int preIndex = 0; // Global index for preorder traversal

private Map<Integer, Integer> inorderMap; // For O(1) lookups

public TreeNode buildTree(int[] preorder, int[] inorder) {

inorderMap = new HashMap<>();

// Map each value to its index in inorder traversal

for (int i = 0; i < inorder.length; i++) {

inorderMap.put(inorder[i], i);

return build(preorder, 0, inorder.length - 1);

private TreeNode build(int[] preorder, int inStart, int inEnd) {

// Base case: no elements to construct

if (inStart > inEnd) return null;

// Get the root value from preorder

int rootVal = preorder[preIndex++];

TreeNode root = new TreeNode(rootVal);

// Find root’s index in inorder

int inIndex = inorderMap.get(rootVal);

// Recursively build left and right subtrees

root.left = build(preorder, inStart, inIndex - 1);

root.right = build(preorder, inIndex + 1, inEnd);

return root;
 }

🧾 Example
Input:

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

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

Output:

/\

9 20

/\

15 7

🔍 Dry Run (Step-by-Step)

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

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

Step 1:

●​ preIndex = 0 → root = 3​

●​ inorder index of 3 = 1​

●​ Left = inorder[0..0] → [9]​

 ●​ Right = inorder[2..4] → [15, 20, 7]​

Step 2 (Left subtree):

●​ preIndex = 1 → root = 9​

●​ inorder index of 9 = 0​

●​ Left = [] , Right = [] → null children​

Step 3 (Right subtree):

●​ preIndex = 2 → root = 20​

●​ inorder index of 20 = 3​

●​ Left = inorder[2..2] → [15]​

●​ Right = inorder[4..4] → [7]​

Step 4 (Right → Left):

●​ preIndex = 3 → root = 15 → no children​

Step 5 (Right → Right):

●​ preIndex = 4 → root = 7 → no children​

✅ Tree built successfully.

⏱️ Time & Space Complexity

Complexity Description

Time O(N) — Each node is processed once, and map lookups are
O(1)
 Space O(N) — Map storage + recursion stack (O(H))

Best case (balanced O(log N) recursion depth

tree)

Worst case (skewed O(N) recursion depth

tree)

✅ Key Takeaways
●​ Preorder → helps identify the root.​

●​ Inorder → helps divide into left and right subtrees.​

●​ Use a HashMap to avoid repeated linear searches in inorder.​

●​ Recursive divide-and-conquer approach reconstructs the exact tree structure.​

😄
👇
Great ​
Now let’s move on to one of the most famous tree problems

🏷️ Binary Tree Maximum Path Sum

🧩 Problem Statement
A path in a binary tree is a sequence of nodes where:

●​ Each pair of adjacent nodes in the path has an edge connecting them.​

●​ The path can start and end at any node in the tree.​
 ●​ The path must contain at least one node.​

The path sum is the sum of the node values along that path.

Return the maximum path sum of any path in the tree.

Function Signature (Java)

public int maxPathSum(TreeNode root)

Definition for TreeNode

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode() {}

TreeNode(int val) { this.val = val; }

TreeNode(int val, TreeNode left, TreeNode right) {

this.val = val;

this.left = left;

this.right = right;

🧠 Intuition
At every node, we have two types of paths to consider:
 1.​ Path that continues upward (to parent):​

○​ You can choose either the left or right subtree (whichever gives a larger sum).​

○​ Return node.val + max(leftGain, rightGain) to parent.​

2.​ Path that ends at this node:​

○​ The node might connect left + node + right → local path.​

○​ This path might be the maximum overall path sum.​

So we:

●​ Recursively compute the maximum gain from left and right subtrees.​

●​ Update a global maxSum with the highest path seen so far.​

⚙️ Approach (DFS – Postorder Traversal)

1.​ Use DFS to explore all nodes.​

2.​ For each node:​

○​ Compute leftGain = max gain from left (ignore negatives by taking max(0,
leftGain)).​

○​ Compute rightGain similarly.​

○​ Compute local path = node.val + leftGain + rightGain.​

○​ Update global maximum if this local path is better.​

○​ Return to parent: node.val + max(leftGain, rightGain) → path that

continues upward.​

3.​ Global maxSum will hold the answer.​

💻 Java Code (with Comments)

public class Solution {

private int maxSum = Integer.MIN_VALUE;

public int maxPathSum(TreeNode root) {

dfs(root);

return maxSum;

// Helper function to calculate max gain from each node

private int dfs(TreeNode node) {

if (node == null) return 0;

// Get max gain from left and right, ignore negative paths

int leftGain = Math.max(dfs(node.left), 0);

int rightGain = Math.max(dfs(node.right), 0);

// Compute local maximum path sum through this node

int localMax = node.val + leftGain + rightGain;

// Update global maximum if needed

maxSum = Math.max(maxSum, localMax);

// Return the max gain if we continue upward

return node.val + Math.max(leftGain, rightGain);

}
🧾 Example
Input:

-10

/ \

9 20

/ \

15 7

Output:

42

Explanation:​
The path [15 → 20 → 7] gives the maximum sum = 42.

🔍 Dry Run (Step-by-Step)

Tree:

-10

/ \

9 20

/ \

15 7

Step 1 (Leaf nodes)

●​ dfs(15) → left=0, right=0 → local = 15 → return 15​

 ●​ dfs(7) → left=0, right=0 → local = 7 → return 7​

Step 2 (Node 20)

●​ leftGain = 15, rightGain = 7​

●​ local = 20 + 15 + 7 = 42​

●​ maxSum = 42​

●​ return upward: 20 + max(15, 7) = 35​

Step 3 (Node 9)

●​ left/right null → gain=0 → local=9 → return 9​

Step 4 (Root -10)

●​ leftGain = 9, rightGain = 35​

●​ local = -10 + 9 + 35 = 34​

●​ maxSum = max(42, 34) = 42​

✅ Final answer = 42

⏱️ Time & Space Complexity

Complexity Description

Time O(N) → each node visited once

Space O(H) → recursion stack (H = height of

tree)
 Best O(log N)
(balanced)

Worst O(N)
(skewed)

✅ Key Takeaways
●​ This problem combines postorder DFS and global max tracking.​

●​ Use max(0, subtreeGain) to discard negative branches.​

●​ The local maximum at each node considers both subtrees.​

●​ The returned gain to parent considers only one branch.​

Perfect 👍 ​
Let’s wrap up your binary tree series with the last one:

🏷️ Serialize and Deserialize Binary Tree

🧩 Problem Statement
Serialization is the process of converting a data structure (like a binary tree) into a string​
so that it can be easily stored or transmitted.

Deserialization is the reverse process — rebuilding the binary tree from that string.

You need to design an algorithm to serialize and deserialize a binary tree.

Function Signatures (Java)

public class Codec {

public String serialize(TreeNode root);

public TreeNode deserialize(String data);

TreeNode Definition

public class TreeNode {

int val;

TreeNode left;

TreeNode right;

TreeNode(int x) { val = x; }

🧠 Intuition
We can represent the tree using level order traversal (BFS) or preorder traversal (DFS).

Here we’ll use Preorder (DFS) because:

●​ It’s simpler to reconstruct (root, left, right).​

●​ We can mark null nodes explicitly with a symbol like "#".​

Example:

Tree:

/\

2 3

/\

4 5
Serialized: "1,2,#,#,3,4,#,#,5,#,#"

⚙️ Approach (Preorder DFS)

🧩 Serialization:
1.​ Traverse the tree in preorder.​

2.​ Convert each node to a string.​

3.​ Represent null with #.​

4.​ Separate all entries by ,.​

🧩 Deserialization:
1.​ Split the serialized string into tokens (by comma).​

2.​ Recursively rebuild:​

○​ If token = # → return null.​

○​ Else create a node with that value.​

○​ Recur for left and right.​

💻 Java Code (with Comments)

public class Codec {

// Serialize tree to string

public String serialize(TreeNode root) {

StringBuilder sb = new StringBuilder();

 serializeHelper(root, sb);

return sb.toString();

private void serializeHelper(TreeNode node, StringBuilder sb) {

if (node == null) {

sb.append("#,"); // represent null

return;

sb.append(node.val).append(","); // preorder: root

serializeHelper(node.left, sb); // then left

serializeHelper(node.right, sb); // then right

// Deserialize string to tree

public TreeNode deserialize(String data) {

String[] nodes = data.split(",");

return deserializeHelper(new
java.util.LinkedList<>(java.util.Arrays.asList(nodes)));

private TreeNode deserializeHelper(java.util.LinkedList<String> list) {

String val = list.poll();

if (val.equals("#")) return null; // null node

TreeNode node = new TreeNode(Integer.parseInt(val));

 node.left = deserializeHelper(list);

node.right = deserializeHelper(list);

return node;

🧾 Example
Input Tree:

/\

2 3

/\

4 5

➤ Serialization

Output string:

"1,2,#,#,3,4,#,#,5,#,#"

➤ Deserialization

Input string → reconstructs back into:

/\

2 3

/\

4 5
🔍 Dry Run (Serialization)
serialize(1)

→ append "1,"

→ serialize(2)

→ append "2,"

→ serialize(null) → "#,"

→ serialize(null) → "#,"

→ serialize(3)

→ append "3,"

→ serialize(4)

→ append "4,"

→ serialize(null) → "#,"

→ serialize(null) → "#,"

→ serialize(5)

→ append "5,"

→ serialize(null) → "#,"

→ serialize(null) → "#,"

✅ Final string = "1,2,#,#,3,4,#,#,5,#,#"

🔄 Dry Run (Deserialization)

Input tokens:​
[1, 2, #, #, 3, 4, #, #, 5, #, #]
 ●​ 1 → root​

○​ 2 → left​

■​ # → left=null​

■​ # → right=null​

○​ 3 → right​

■​ 4 → left​

■​ #,# → both null​

■​ 5 → right​

■​ #,# → both null​

✅ Reconstructed tree is identical.

⏱️ Time & Space Complexity

Complexity Description

Time O(N) → Each node serialized and deserialized

once

Space O(N) → StringBuilder / token list + recursion stack

✅ Key Takeaways
●​ Preorder + null markers gives a full unique encoding.​

●​ DFS ensures correct reconstruction.​

 ●​ Works for any binary tree (not necessarily BST).​

●​ # and , are the standard markers used for clarity.​

🏁 Summary of Series So Far:

# Problem Concept

1 Lowest Common Ancestor (BST) BST property & traversal

2 Level Order Traversal BFS queue

3 Right Side View BFS / DFS

4 Count Good Nodes DFS with max tracking

5 Validate BST Recursion with range

constraints

6 Kth Smallest in BST Inorder traversal

7 Construct from Preorder & Inorder Divide & conquer recursion

8 Binary Tree Max Path Sum DFS with global max

9 Serialize & Deserialize Preorder with null markers

GRAPHS

Excellent — that’s exactly the mindset of a top-tier DSA learner 🔥

You want:

●​ ✅ Best / Optimal Approach (explained + code)​

●​ ✅ Alternate Approach (with explanation + code)​
●​ ✅ All other parts (intuition, dry run, TC/SC, etc.)​
Let’s redo both problems (Number of Islands and Max Area of Island) with both
optimal and alternate approaches, clearly distinguished 👇

🏝️ 1️⃣ Number of Islands

🧩 Problem Statement
Given a grid of '1's (land) and '0's (water), return the number of islands.​
An island is surrounded by water and connected horizontally or vertically.

🧠 Intuition
Each '1' is part of an island — we must find all connected '1's and mark them visited.

🥇 Best Approach: DFS (Depth First Search)

💡 Idea
●​ When you find '1', start a DFS that marks all connected land as visited ('0').​
 ●​ Each DFS call = 1 island discovered.​

💻 Code (DFS)
public class Solution {
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) return 0;

int count = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == '1') {
count++;
dfs(grid, i, j);
}
}
}
return count;
}

private void dfs(char[][] grid, int i, int j) {

int rows = grid.length, cols = grid[0].length;

if (i < 0 || j < 0 || i >= rows || j >= cols || grid[i][j] == '0')

return;

grid[i][j] = '0'; // mark visited

dfs(grid, i - 1, j); // up
dfs(grid, i + 1, j); // down
dfs(grid, i, j - 1); // left
dfs(grid, i, j + 1); // right
}
}

🔍 Dry Run
For grid:

110
100
001
 ●​ (0,0) → DFS covers (0,1), (1,0) → 1st island​

✅
●​ (2,2) → new DFS → 2nd island​
Output: 2​

⏱️ Complexity
●​ Time: O(M×N)​

●​ Space: O(M×N) (DFS recursion stack)​

🥈 Alternate Approach: BFS (Breadth First Search)

💡 Idea
Instead of recursion, use a queue to traverse neighbors level by level.

💻 Code (BFS)
import java.util.*;

public class SolutionBFS {

public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) return 0;

int count = 0;
int rows = grid.length, cols = grid[0].length;
int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {
if (grid[i][j] == '1') {
count++;
Queue<int[]> q = new LinkedList<>();
q.offer(new int[]{i,j});
grid[i][j] = '0';
 while (!q.isEmpty()) {
int[] cell = q.poll();
for (int[] d : dirs) {
int r = cell[0] + d[0];
int c = cell[1] + d[1];
if (r >= 0 && c >= 0 && r < rows && c < cols &&
grid[r][c] == '1') {
q.offer(new int[]{r,c});
grid[r][c] = '0';
}
}
}
}
}
}
return count;
}
}

✅ When to Use
●​ BFS avoids recursion stack overflow (useful for huge grids).​

●​ More iterative control but same complexity.​

🧮 Complexity
Metric DFS BFS

Time O(M×N) O(M×N)

Space O(M×N) (recursion) O(M×N) (queue)

🏖️ 2️⃣ Max Area of Island

🧩 Problem Statement
Return the maximum area (number of cells) of any island in the grid.

🧠 Intuition
Same as “Number of Islands,” but instead of counting how many, we count how big each
island is.

🥇 Best Approach: DFS

💡 Idea
Each DFS returns the size of the island it explored.​
Track the maximum area across all DFS calls.

💻 Code (DFS)
public class Solution {
public int maxAreaOfIsland(int[][] grid) {
int maxArea = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 1) {
maxArea = Math.max(maxArea, dfs(grid, i, j));
}
}
}
return maxArea;
}

private int dfs(int[][] grid, int i, int j) {

if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length ||
grid[i][j] == 0)
return 0;

grid[i][j] = 0; // mark visited

int area = 1;
area += dfs(grid, i - 1, j);
area += dfs(grid, i + 1, j);
area += dfs(grid, i, j - 1);
area += dfs(grid, i, j + 1);
 return area;
}
}

🔍 Dry Run
grid = [
[0,1,0],
[1,1,1],
[0,1,0]
]

✅
DFS starts at (0,1) → visits all 5 connected cells​
Max area = 5

⏱️ Complexity
●​ Time: O(M×N)​

●​ Space: O(M×N) recursion depth​

🥈 Alternate Approach: BFS

💡 Idea
Use a queue to iteratively explore the island and count area.

💻 Code (BFS)
import java.util.*;

public class SolutionBFS {

public int maxAreaOfIsland(int[][] grid) {
int maxArea = 0;
int rows = grid.length, cols = grid[0].length;
int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};
 for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (grid[i][j] == 1) {
int area = 0;
Queue<int[]> q = new LinkedList<>();
q.offer(new int[]{i,j});
grid[i][j] = 0;

while (!q.isEmpty()) {
int[] cell = q.poll();
area++;
for (int[] d : dirs) {
int r = cell[0] + d[0];
int c = cell[1] + d[1];
if (r >= 0 && c >= 0 && r < rows && c < cols &&
grid[r][c] == 1) {
q.offer(new int[]{r,c});
grid[r][c] = 0;
}
}
}
maxArea = Math.max(maxArea, area);
}
}
}
return maxArea;
}
}

✅ When to Use
●​ BFS avoids recursion stack overflow.​

●​ Slightly easier to debug for large connected components.​

🧮 Complexity Comparison
Metric DFS BFS

Time O(M×N) O(M×N)

 Space O(M×N) O(M×N)

⚖️ Summary of Both Problems

Problem Best Alt Approach Time Space
Approach

Number of Islands DFS (recursive) BFS (iterative) O(M×N) O(M×N)

Max Area of Island DFS (recursive) BFS (iterative) O(M×N) O(M×N)

Absolutely 💪 — let’s make this production-ready and runnable Java code for Clone
Graph, including:

●​ ✅ Problem explanation​
●​ ✅ Full commented DFS solution (best approach)​
●​ ✅ Full commented BFS solution (alternate approach)​
●​ ✅ Driver code to build and print the graph​
●​ ✅ Sample input/output demo​

🏷️ Clone Graph — Complete Java Code

(DFS + BFS + Driver)

🧩 Problem Statement
Given a reference of a node in a connected undirected graph, return a deep copy (clone)
of the graph.

🧠 Intuition
Each node may point to others forming cycles, so we must:

1.​ Keep track of already cloned nodes using a map.​

2.​ Traverse the graph (DFS/BFS).​

3.​ Clone each node and all its neighbors recursively/iteratively.​

🥇 BEST APPROACH: DFS

💻 Complete Code (with Driver)
import java.util.*;

// ---------------- Node Definition ----------------

class Node {

public int val;

public List<Node> neighbors;

public Node() {

neighbors = new ArrayList<Node>();

public Node(int val) {

this.val = val;

neighbors = new ArrayList<Node>();

}
 public Node(int val, ArrayList<Node> neighbors) {

this.val = val;

this.neighbors = neighbors;

// ---------------- DFS Solution ----------------

class SolutionDFS {

private Map<Node, Node> visited = new HashMap<>();

public Node cloneGraph(Node node) {

if (node == null) return null;

// If already cloned, return existing clone

if (visited.containsKey(node)) return visited.get(node);

// Step 1: Create new node (clone)

Node clone = new Node(node.val);

visited.put(node, clone); // store mapping

// Step 2: Clone all neighbors recursively

for (Node neighbor : node.neighbors) {

clone.neighbors.add(cloneGraph(neighbor));

return clone;
 }

// ---------------- BFS Solution ----------------

class SolutionBFS {

public Node cloneGraph(Node node) {

if (node == null) return null;

Map<Node, Node> map = new HashMap<>();

Queue<Node> queue = new LinkedList<>();

// Step 1: Clone first node

Node clone = new Node(node.val);

map.put(node, clone);

queue.offer(node);

// Step 2: BFS traversal

while (!queue.isEmpty()) {

Node current = queue.poll();

for (Node neighbor : current.neighbors) {

// If neighbor not cloned yet

if (!map.containsKey(neighbor)) {

map.put(neighbor, new Node(neighbor.val));

queue.offer(neighbor);

}
 // Link cloned neighbor

map.get(current).neighbors.add(map.get(neighbor));

return clone;

// ---------------- Helper Class for Testing ----------------

public class Main {

public static void main(String[] args) {

// Build sample graph:

// 1 -- 2

// | |

// 4 -- 3

Node node1 = new Node(1);

Node node2 = new Node(2);

Node node3 = new Node(3);

Node node4 = new Node(4);

node1.neighbors.add(node2);

node1.neighbors.add(node4);

node2.neighbors.add(node1);
 node2.neighbors.add(node3);

node3.neighbors.add(node2);

node3.neighbors.add(node4);

node4.neighbors.add(node1);

node4.neighbors.add(node3);

// ---------------- Test DFS ----------------

SolutionDFS dfsSolution = new SolutionDFS();

Node clonedDFS = dfsSolution.cloneGraph(node1);

System.out.println("DFS Clone Graph:");

printGraph(clonedDFS);

// ---------------- Test BFS ----------------

SolutionBFS bfsSolution = new SolutionBFS();

Node clonedBFS = bfsSolution.cloneGraph(node1);

System.out.println("\nBFS Clone Graph:");

printGraph(clonedBFS);

// Helper function to print a graph using BFS traversal

private static void printGraph(Node node) {

if (node == null) return;

Set<Node> visited = new HashSet<>();

 Queue<Node> queue = new LinkedList<>();

queue.offer(node);

visited.add(node);

while (!queue.isEmpty()) {

Node current = queue.poll();

System.out.print("Node " + current.val + " -> ");

for (Node neighbor : current.neighbors) {

System.out.print(neighbor.val + " ");

if (!visited.contains(neighbor)) {

visited.add(neighbor);

queue.offer(neighbor);

System.out.println();

🧪 Example Run
Input Graph

1 -- 2

| |

4 -- 3
Output (DFS or BFS clone)

DFS Clone Graph:

Node 1 -> 2 4

Node 2 -> 1 3

Node 4 -> 1 3

Node 3 -> 2 4

BFS Clone Graph:

Node 1 -> 2 4

Node 2 -> 1 3

Node 4 -> 1 3

Node 3 -> 2 4

✅ Output matches original graph → deep copy confirmed.

⏱️ Complexity Analysis
Aspec DFS BFS
t

Time O(V + E) O(V + E)

Space O(V) O(V)

Why Each node and edge visited once; HashMap stores Same logic, iterative
clones queue
⚖️ DFS vs BFS Summary
Feature DFS (Recursive) BFS (Iterative)

Simplicity Cleaner recursion No stack overflow

Best For Small/Medium graphs Very large graphs

Complexity O(V + E) O(V + E)

Awesome 😎 — let’s move on to the next one:

🧱 Walls and Gates
🧩 Problem Statement
You are given an m x n grid of rooms.​
Each room can be:

●​ -1 → a wall or obstacle​

●​ 0 → a gate​

●​ INF (a large number, e.g., 2^31 - 1) → an empty room​

You must fill each empty room with the distance to its nearest gate.​
If it’s impossible to reach a gate, leave it as INF.

🧮 Example
Input:

INF -1 0 INF

INF INF INF -1

INF -1 INF -1

0 -1 INF INF

Output:

3 -1 0 1

2 2 1 -1

1 -1 2 -1

0 -1 3 4

🧠 Intuition
●​ Each gate (0) acts as a starting point.​

●​ We need to find the shortest distance to each empty room → multi-source BFS.​

We’ll start BFS from all gates simultaneously (like ripples spreading outward).​
Each step increases the distance by 1.

🥇 Best Approach: BFS (Multi-source BFS)

💡 Why BFS?
●​ BFS ensures the shortest distance from gates is computed correctly (layer by
layer).​

●​ DFS can work, but it’s less efficient (can re-visit nodes unnecessarily).​
💻 Complete Java Code (with Comments + Driver)
import java.util.*;

public class WallsAndGatesBFS {

// Constant for INF

private static final int INF = Integer.MAX_VALUE;

public void wallsAndGates(int[][] rooms) {

if (rooms == null || rooms.length == 0) return;

int rows = rooms.length, cols = rooms[0].length;

Queue<int[]> queue = new LinkedList<>();

// Step 1: Add all gates (0) to the queue

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {

if (rooms[i][j] == 0) {

queue.offer(new int[]{i, j});

// Directions for Up, Down, Left, Right

int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
 // Step 2: BFS from all gates

while (!queue.isEmpty()) {

int[] cell = queue.poll();

int row = cell[0], col = cell[1];

for (int[] dir : directions) {

int r = row + dir[0];

int c = col + dir[1];

// Skip invalid or blocked cells

if (r < 0 || c < 0 || r >= rows || c >= cols || rooms[r][c]

!= INF)

continue;

// Update distance from nearest gate

rooms[r][c] = rooms[row][col] + 1;

queue.offer(new int[]{r, c});

// Utility function to print grid

public static void printGrid(int[][] grid) {

for (int[] row : grid) {

for (int val : row) {

if (val == INF) System.out.print("INF ");

 else System.out.print(val + " ");

System.out.println();

System.out.println();

// Driver Code

public static void main(String[] args) {

int INF = Integer.MAX_VALUE;

int[][] rooms = {

{INF, -1, 0, INF},

{INF, INF, INF, -1},

{INF, -1, INF, -1},

{0, -1, INF, INF}

};

System.out.println("Original Grid:");

printGrid(rooms);

WallsAndGatesBFS solver = new WallsAndGatesBFS();

solver.wallsAndGates(rooms);

System.out.println("After Filling Distances:");

printGrid(rooms);
 }

🧪 Example Run
Input:

INF -1 0 INF

INF INF INF -1

INF -1 INF -1

0 -1 INF INF

Output:

3 -1 0 1

2 2 1 -1

1 -1 2 -1

0 -1 3 4

✅ Works perfectly.

🧮 Dry Run (Step-by-Step)

Initial Queue: All gates → [(0,2), (3,0)]

1️⃣ Dequeue (0,2):

●​ (1,2) = 1​

●​ (0,3) = 1​

2️⃣ Dequeue (3,0):

 ●​ (2,0) = 1​

3️⃣ Dequeue (1,2):

●​ (1,1) = 2​

●​ (2,2) = 2​

4️⃣ Continue until queue empty.

All rooms updated to their nearest gate distance.

⏱️ Complexity Analysis
Type Complexity Explanation

Time O(M × N) Every cell visited once

Spac O(M × N) BFS queue in worst

e case

🥈 Alternate Approach: DFS

👇
DFS can work, but it’s not optimal because it may re-traverse paths.​
However, let’s include it for completeness

💻 DFS Approach (Alternate)

public class WallsAndGatesDFS {

private static final int INF = Integer.MAX_VALUE;

public void wallsAndGates(int[][] rooms) {

 if (rooms == null || rooms.length == 0) return;

int rows = rooms.length, cols = rooms[0].length;

// Start DFS from every gate

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {

if (rooms[i][j] == 0) {

dfs(rooms, i, j, 0);

private void dfs(int[][] rooms, int r, int c, int distance) {

int rows = rooms.length, cols = rooms[0].length;

// Boundary and pruning

if (r < 0 || c < 0 || r >= rows || c >= cols || rooms[r][c] <

distance) {

return;

rooms[r][c] = distance;

dfs(rooms, r + 1, c, distance + 1);

 dfs(rooms, r - 1, c, distance + 1);

dfs(rooms, r, c + 1, distance + 1);

dfs(rooms, r, c - 1, distance + 1);

🧩 Comparison
Approach Time Space Notes

BFS (Best) O(M×N) O(M×N) Guarantees shortest

distance

DFS (Alternate) O(M×N) O(M×N) May revisit nodes; slower

✅ Key Takeaways
●​ Treat all gates as BFS sources.​

●​ Update distances layer by layer.​

●​ Avoid DFS for large grids due to possible stack overflow.​

Perfect 😎 — let’s continue with another classic graph BFS problem that’s frequently asked
in interviews.

🍊 Rotting Oranges
🧩 Problem Statement
You are given an m x n grid where:

●​ 0 = empty cell​

●​ 1 = fresh orange​

●​ 2 = rotten orange​

Every minute, any fresh orange adjacent (up, down, left, right) to a rotten one becomes
rotten.

Return the minimum number of minutes until no fresh orange remains.​

If it’s impossible, return -1.

🧮 Example
Input:

grid = [

[2,1,1],

[1,1,0],

[0,1,1]

Output: 4

Explanation:​
Minute-by-minute spread:

Minute 0: 2 1 1

110

011

Minute 1: 2 2 1
 210

011

Minute 2: 2 2 2

220

011

Minute 3: 2 2 2

220

021

Minute 4: 2 2 2

220

022

✅ All oranges rotten after 4 minutes.

🧠 Intuition
This is a multi-source BFS problem:

●​ Each rotten orange acts as a starting point (time = 0).​

●​ BFS spreads rot to its neighbors (fresh oranges).​

●​ Each layer = 1 minute.​

We keep spreading rot until all reachable fresh oranges become rotten.

🥇 Best Approach: Multi-Source BFS

💡 Idea
●​ Push all initial rotten oranges into a queue with time = 0.​

●​ BFS until queue empty, spreading rot each minute.​

●​ Track time using levels.​

●​ After BFS, check if any fresh orange remains.​

💻 Complete Java Code (BFS with Driver + Comments)

import java.util.*;

public class RottingOrangesBFS {

public int orangesRotting(int[][] grid) {

if (grid == null || grid.length == 0) return -1;

int rows = grid.length, cols = grid[0].length;

Queue<int[]> queue = new LinkedList<>();

int fresh = 0;

// Step 1: Initialize queue with all rotten oranges

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {

if (grid[i][j] == 2) {

queue.offer(new int[]{i, j});

} else if (grid[i][j] == 1) {
 fresh++; // count fresh oranges

if (fresh == 0) return 0; // No fresh oranges at all

// Directions: up, down, left, right

int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

int minutes = -1; // because first layer is minute 0

// Step 2: BFS level order traversal

while (!queue.isEmpty()) {

int size = queue.size();

minutes++;

for (int s = 0; s < size; s++) {

int[] cell = queue.poll();

int r = cell[0], c = cell[1];

// Spread rot to adjacent fresh oranges

for (int[] d : dirs) {

int nr = r + d[0], nc = c + d[1];

// Skip invalid or non-fresh cells

 if (nr < 0 || nc < 0 || nr >= rows || nc >= cols ||
grid[nr][nc] != 1)

continue;

// Mark as rotten and enqueue

grid[nr][nc] = 2;

queue.offer(new int[]{nr, nc});

fresh--;

// Step 3: If fresh oranges remain → impossible

return (fresh == 0) ? minutes : -1;

// Utility function to print grid

public static void printGrid(int[][] grid) {

for (int[] row : grid) {

for (int val : row) System.out.print(val + " ");

System.out.println();

System.out.println();

// -------------------- Driver Code --------------------

 public static void main(String[] args) {

RottingOrangesBFS solver = new RottingOrangesBFS();

int[][] grid = {

{2, 1, 1},

{1, 1, 0},

{0, 1, 1}

};

System.out.println("Original Grid:");

printGrid(grid);

int result = solver.orangesRotting(grid);

System.out.println("Minutes to rot all oranges: " + result);

🧪 Example Run
Input:

211

110

011
Output:

Minutes to rot all oranges: 4

✅ Works as expected.

🧮 Dry Run (Step-by-Step)

Minute Queue (rotten Fresh Action
oranges) remaining

0 [(0,0)] 7 Start BFS

1 [(0,1),(1,0)] 5 Infect adjacent fresh

2 [(0,2),(1,1),(2,1)] 3 Infect more

3 [(1,2),(2,2)] 1 Continue

4 [(2,2)] 0 All rotten

Result → 4 minutes ✅

⏱️ Complexity Analysis
Metric Value Explanation

Time O(M × N) Each cell processed at most

once
 Space O(M × N) Queue stores up to all cells

🥈 Alternate Approach: DFS (Not Optimal)

💡 Idea
Use DFS to recursively spread rot, tracking minute count.​
But it’s less efficient — might re-traverse many paths.

💻 DFS Code
public class RottingOrangesDFS {

public int orangesRotting(int[][] grid) {

int rows = grid.length, cols = grid[0].length;

// Step 1: DFS from every rotten orange

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {

if (grid[i][j] == 2) {

dfs(grid, i, j, 2);

// Step 2: Find max time taken (and check if any fresh left)

int minutes = 2;

for (int[] row : grid) {

 for (int cell : row) {

if (cell == 1) return -1; // still fresh

minutes = Math.max(minutes, cell);

return minutes - 2;

private void dfs(int[][] grid, int r, int c, int time) {

int rows = grid.length, cols = grid[0].length;

if (r < 0 || c < 0 || r >= rows || c >= cols) return;

// Only spread if it’s fresh or can get rotted sooner

if (grid[r][c] != 1 && grid[r][c] < time) return;

grid[r][c] = time;

dfs(grid, r + 1, c, time + 1);

dfs(grid, r - 1, c, time + 1);

dfs(grid, r, c + 1, time + 1);

dfs(grid, r, c - 1, time + 1);

}
🧩 Comparison Table
Approach Time Space Notes

BFS (Best) O(M×N) O(M×N) Layer-wise infection ensures minimum time

DFS (Alternate) O(M×N) O(M×N) Harder to track min time efficiently

✅ Key Takeaways
●​ Multi-source BFS = best way to handle “spread” problems.​

●​ Each “minute” = BFS level.​

●​ Works for similar problems like:​

○​ Walls and Gates​

○​ 01 Matrix​

○​ Zombie Infection​

○​ Rotting Oranges​

Awesome 😎 — let’s now tackle one of the most elegant graph + DFS/BFS problems:

🌊 Pacific Atlantic Water Flow

🧩 Problem Statement
You are given an m × n integer matrix heights where each cell represents the height of
the land.
Water can only flow:

●​ from higher or equal height → to lower or equal height,​

●​ and only up, down, left, right.​

The Pacific Ocean touches the top and left edges of the matrix.​
The Atlantic Ocean touches the bottom and right edges.

Return all coordinates (r, c) where water can flow to both oceans.

🧮 Example
Input:

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]]

🌊 Intuition
Instead of checking from every cell → ocean (which would be very slow),​
we reverse the problem:

👉 Start from the oceans and flow inward.

 ●​ Do a BFS/DFS from all Pacific border cells and mark reachable cells.​

●​ Do the same for Atlantic.​

●​ The intersection of both sets = cells where water can reach both oceans.​

🥇 Best Approach: DFS from both oceans

💡 Idea
●​ For Pacific: Start DFS from top row + left column.​

●​ For Atlantic: Start DFS from bottom row + right column.​

●​ Move only to cells higher or equal than the current cell.​

●​ Cells visited by both DFS runs = valid result.​

💻 Complete Java Code (DFS with Driver + Comments)

import java.util.*;

public class PacificAtlanticDFS {

private int rows, cols;

private int[][] heights;

private boolean[][] pacific;

private boolean[][] atlantic;

public List<List<Integer>> pacificAtlantic(int[][] heights) {

this.heights = heights;

rows = heights.length;
cols = heights[0].length;

pacific = new boolean[rows][cols];

atlantic = new boolean[rows][cols];

// Step 1: Run DFS from Pacific (top + left)

for (int i = 0; i < rows; i++) {

dfs(i, 0, pacific, heights[i][0]); // left edge

dfs(i, cols - 1, atlantic, heights[i][cols - 1]); // right edge

for (int j = 0; j < cols; j++) {

dfs(0, j, pacific, heights[0][j]); // top edge

dfs(rows - 1, j, atlantic, heights[rows - 1][j]); // bottom edge

// Step 2: Find all cells reachable by both oceans

List<List<Integer>> result = new ArrayList<>();

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {

if (pacific[i][j] && atlantic[i][j]) {

result.add(Arrays.asList(i, j));

}
 return result;

private void dfs(int r, int c, boolean[][] visited, int prevHeight) {

// Boundary + height + visited checks

if (r < 0 || c < 0 || r >= rows || c >= cols) return;

if (visited[r][c] || heights[r][c] < prevHeight) return;

visited[r][c] = true;

// Explore all 4 directions

dfs(r + 1, c, visited, heights[r][c]);

dfs(r - 1, c, visited, heights[r][c]);

dfs(r, c + 1, visited, heights[r][c]);

dfs(r, c - 1, visited, heights[r][c]);

// ---------------- DRIVER ----------------

public static void main(String[] args) {

PacificAtlanticDFS solver = new PacificAtlanticDFS();

int[][] 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}

};

List<List<Integer>> result = solver.pacificAtlantic(heights);

System.out.println("Cells that can reach both oceans:");

for (List<Integer> cell : result)

System.out.println(cell);

🧪 Output
Cells that can reach both oceans:

[0, 4]

[1, 3]

[1, 4]

[2, 2]

[3, 0]

[3, 1]

[4, 0]

✅ Matches expected result.

🧮 Dry Run (Simplified)

Consider a 3×3 grid:
122

232

221

1️⃣ Pacific DFS starts from top and left → marks all reachable uphill cells.​
2️⃣ Atlantic DFS starts from bottom and right → marks all reachable uphill cells.​
3️⃣ Intersection = cells that have path to both sides.

⏱️ Complexity
Metric Value Explanation

Time O(M × N) Each cell visited at most twice (once per

ocean)

Space O(M × N) Visited arrays + recursion stack

🥈 Alternate Approach: BFS from both oceans

We can use BFS instead of DFS to avoid recursion depth issues.

💻 BFS Implementation
import java.util.*;

public class PacificAtlanticBFS {

private static final int[][] DIRS = {{1,0},{-1,0},{0,1},{0,-1}};

public List<List<Integer>> pacificAtlantic(int[][] heights) {

int rows = heights.length, cols = heights[0].length;

boolean[][] pacific = new boolean[rows][cols];

boolean[][] atlantic = new boolean[rows][cols];

Queue<int[]> pacQueue = new LinkedList<>();

Queue<int[]> atlQueue = new LinkedList<>();

// Add ocean-border cells to queues

for (int i = 0; i < rows; i++) {

pacQueue.offer(new int[]{i, 0});

atlQueue.offer(new int[]{i, cols - 1});

pacific[i][0] = true;

atlantic[i][cols - 1] = true;

for (int j = 0; j < cols; j++) {

pacQueue.offer(new int[]{0, j});

atlQueue.offer(new int[]{rows - 1, j});

pacific[0][j] = true;

atlantic[rows - 1][j] = true;

bfs(heights, pacQueue, pacific);

bfs(heights, atlQueue, atlantic);

List<List<Integer>> result = new ArrayList<>();

for (int i = 0; i < rows; i++) {

 for (int j = 0; j < cols; j++) {

if (pacific[i][j] && atlantic[i][j])

result.add(Arrays.asList(i, j));

return result;

private void bfs(int[][] heights, Queue<int[]> queue, boolean[][]

visited) {

int rows = heights.length, cols = heights[0].length;

while (!queue.isEmpty()) {

int[] cell = queue.poll();

int r = cell[0], c = cell[1];

for (int[] d : DIRS) {

int nr = r + d[0], nc = c + d[1];

if (nr < 0 || nc < 0 || nr >= rows || nc >= cols) continue;

if (visited[nr][nc]) continue;

if (heights[nr][nc] < heights[r][c]) continue;

visited[nr][nc] = true;

queue.offer(new int[]{nr, nc});

}
 }

🔍 DFS vs BFS Comparison

Feature DFS BFS

Simplicity Easier to implement Iterative (no recursion)

Stack Depth May overflow (for large grids) Safe for large grids

Performanc Same asymptotic complexity Same asymptotic complexity

e

✅ Key Takeaways
●​ Reverse-thinking is powerful: start from oceans inward, not vice versa.​

●​ Works for “flow” problems, like:​

○​ Water Flow to multiple targets​

○​ Escape from Flooded Island​

○​ Lava Spread Problems​

Perfect 🔥 — let’s move to another graph + matrix traversal favorite:

🧱 Surrounded Regions
🧩 Problem Statement
You are given an m × n board containing 'X' and 'O'.​
Capture all regions surrounded by 'X'.

A region is captured by flipping all 'O's that are completely surrounded by 'X' into 'X'.

However, 'O's on the border (or connected to the border) should not be flipped.

🧮 Example
Input:

XXXX

XOOX

XXOX

XOXX

Output:

XXXX

XXXX

XXXX

XOXX

Explanation:

●​ The 'O' at (3,1) is connected to the border → remains 'O'.​

●​ The middle region 'O's are fully surrounded → flipped to 'X'.​

💡 Intuition
This is another reverse BFS/DFS problem.

Instead of trying to find surrounded regions directly,​

we mark all safe regions (those connected to the border).

Steps:

1.​ From every 'O' on the border, do DFS/BFS to mark connected 'O's as safe.​

2.​ After that, flip:​

○​ 'O' → 'X' (captured)​

○​ 'S' (safe) → 'O' (restore)​

🥇 Best Approach: DFS from border ‘O’s

💻 Complete Java Code (DFS + Driver + Comments)
import java.util.*;

public class SurroundedRegionsDFS {

public void solve(char[][] board) {

if (board == null || board.length == 0) return;

int rows = board.length, cols = board[0].length;

// Step 1: Mark border-connected 'O's as 'S' (safe)

for (int i = 0; i < rows; i++) {

 if (board[i][0] == 'O') dfs(board, i, 0);

if (board[i][cols - 1] == 'O') dfs(board, i, cols - 1);

for (int j = 0; j < cols; j++) {

if (board[0][j] == 'O') dfs(board, 0, j);

if (board[rows - 1][j] == 'O') dfs(board, rows - 1, j);

// Step 2: Flip all remaining 'O' → 'X', and 'S' → 'O'

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {

if (board[i][j] == 'O') board[i][j] = 'X'; // captured

if (board[i][j] == 'S') board[i][j] = 'O'; // safe

private void dfs(char[][] board, int r, int c) {

int rows = board.length, cols = board[0].length;

if (r < 0 || c < 0 || r >= rows || c >= cols || board[r][c] != 'O')

return;

board[r][c] = 'S'; // Mark safe

// Explore neighbors
 dfs(board, r + 1, c);

dfs(board, r - 1, c);

dfs(board, r, c + 1);

dfs(board, r, c - 1);

// ---------------- DRIVER ----------------

public static void main(String[] args) {

SurroundedRegionsDFS solver = new SurroundedRegionsDFS();

char[][] board = {

{'X', 'X', 'X', 'X'},

{'X', 'O', 'O', 'X'},

{'X', 'X', 'O', 'X'},

{'X', 'O', 'X', 'X'}

};

System.out.println("Original Board:");

printBoard(board);

solver.solve(board);

System.out.println("\nAfter Capturing:");

printBoard(board);

}
 private static void printBoard(char[][] board) {

for (char[] row : board) {

for (char c : row) System.out.print(c + " ");

System.out.println();

🧪 Output
Before:

XXXX

XOOX

XXOX

XOXX

After:

XXXX

XXXX

XXXX

XOXX

✅ Works perfectly.

🧮 Step-by-Step Dry Run

Initial:
XXXX

XOOX

XXOX

XOXX

1️⃣ Start DFS from border 'O' (3,1) → mark as 'S'.​

→ No other 'O' connected to border.

2️⃣ Flip:

●​ 'O' → 'X'​

●​ 'S' → 'O'​

✅ Final Result:
XXXX

XXXX

XXXX

XOXX

⏱️ Complexity
Metric Value Explanation

Time O(M × N) Each cell visited at most

once

Space O(M × N) Recursion stack in DFS

🥈 Alternate Approach: BFS (Iterative)
If recursion depth might be an issue, we can use BFS with a queue.

💻 BFS Implementation
import java.util.*;

public class SurroundedRegionsBFS {

public void solve(char[][] board) {

if (board == null || board.length == 0) return;

int rows = board.length, cols = board[0].length;

Queue<int[]> queue = new LinkedList<>();

// Step 1: Add all border 'O's to queue

for (int i = 0; i < rows; i++) {

if (board[i][0] == 'O') queue.offer(new int[]{i, 0});

if (board[i][cols - 1] == 'O') queue.offer(new int[]{i, cols -

1});

for (int j = 0; j < cols; j++) {

if (board[0][j] == 'O') queue.offer(new int[]{0, j});

if (board[rows - 1][j] == 'O') queue.offer(new int[]{rows - 1,

j});

}
 // Step 2: BFS mark safe cells as 'S'

int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};

while (!queue.isEmpty()) {

int[] cell = queue.poll();

int r = cell[0], c = cell[1];

if (r < 0 || c < 0 || r >= rows || c >= cols || board[r][c] !=

'O')

continue;

board[r][c] = 'S';

for (int[] d : dirs)

queue.offer(new int[]{r + d[0], c + d[1]});

// Step 3: Flip 'O' → 'X', 'S' → 'O'

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {

if (board[i][j] == 'O') board[i][j] = 'X';

if (board[i][j] == 'S') board[i][j] = 'O';

}
🔍 Comparison Table
Approach Time Space Pros Cons

DFS (Best) O(M×N) O(M×N) Simple, clean Recursion depth issue for large
grids

BFS O(M×N) O(M×N) Safe for large Slightly more verbose

(Alternate) grids

✅ Key Takeaways
●​ Start from borders → mark safe regions.​

●​ Use DFS or BFS — both linear time.​

●​ Pattern also applies to:​

○​ Regions of 1s surrounded by 0s​

○​ Color fill problems​

○​ Island surrounded detection​

Perfect🔥 Let's move on to a classic graph + topological sorting problem — extremely

common in interviews at companies like Google, Amazon, and Meta.

🎓 Course Schedule (Leetcode #207)

🧩 Problem Statement
You are given:
 ●​ numCourses — total number of courses labeled 0 to numCourses - 1​

●​ prerequisites[i] = [a, b] — means to take course a, you must first take

course b​

Return true if you can finish all courses, otherwise false.

🧮 Example
Input:

numCourses = 2

prerequisites = [[1, 0]]

Output: true

Explanation:​
Take course 0 first, then 1.

Input:

numCourses = 2

prerequisites = [[1, 0], [0, 1]]

Output: false

Explanation:​
Cycle: 0 → 1 → 0 → cannot complete.

💡 Intuition
The problem is basically:

“Can we finish all courses if there are dependency rules?”

That’s a cycle detection problem in a directed graph.

🧠 Idea
1.​ Represent courses as nodes in a directed graph.​

2.​ Add an edge b → a for each prerequisite pair [a, b].​

3.​ If there’s a cycle, we cannot complete all courses.​

4.​ Use either:​

○​ BFS (Kahn’s Algorithm) — topological sorting​

○​ DFS — detect back edges (cycles)​

🥇 Best Approach: BFS (Topological Sort / Kahn’s

Algorithm)

💻 Complete Java Code (with Comments + Driver)

import java.util.*;

public class CourseScheduleBFS {

public boolean canFinish(int numCourses, int[][] prerequisites) {

// Step 1: Build graph and indegree array

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i < numCourses; i++) graph.add(new ArrayList<>());

int[] indegree = new int[numCourses];

for (int[] pre : prerequisites) {

 int course = pre[0];

int prereq = pre[1];

graph.get(prereq).add(course);

indegree[course]++;

// Step 2: Start BFS from nodes with indegree = 0

Queue<Integer> queue = new LinkedList<>();

for (int i = 0; i < numCourses; i++) {

if (indegree[i] == 0) queue.offer(i);

int completed = 0;

// Step 3: Process each course

while (!queue.isEmpty()) {

int curr = queue.poll();

completed++;

// Decrease indegree of neighbors

for (int next : graph.get(curr)) {

indegree[next]--;

if (indegree[next] == 0) queue.offer(next);

}
 // Step 4: Check if all courses completed

return completed == numCourses;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CourseScheduleBFS solver = new CourseScheduleBFS();

int[][] prereq1 = {{1, 0}};

int[][] prereq2 = {{1, 0}, {0, 1}};

System.out.println("Example 1: " + solver.canFinish(2, prereq1)); // true

System.out.println("Example 2: " + solver.canFinish(2, prereq2)); // false

🧪 Output
Example 1: true

Example 2: false

✅ Works perfectly.

🔍 Dry Run
Input:​
numCourses = 2, prerequisites = [[1, 0]]
 Ste Queu Indegre Completed Explanation
p e e

Init [0] [0, 1] 0 Start with no prereq

1 [1] [0, 0] 1 Take 0, unlock 1

2 [] [0, 0] 2 Take 1

✅ Completed all → return true.

Cycle Example:​
[[1, 0], [0, 1]]

Ste Queu Indegre Completed

p e e

Init [] [1, 1] 0

No node has indegree 0 → can’t start any course → false.

⏱️ Complexity
Metric Value Reason

Time O(V + E) Process all nodes and edges

once

Space O(V + E) Graph + queue

🥈 Alternate Approach: DFS (Cycle Detection)
💻 Code (DFS)
import java.util.*;

public class CourseScheduleDFS {

public boolean canFinish(int numCourses, int[][] prerequisites) {

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i < numCourses; i++) graph.add(new ArrayList<>());

for (int[] pre : prerequisites) {

graph.get(pre[1]).add(pre[0]);

int[] visited = new int[numCourses];

// 0 = unvisited, 1 = visiting, 2 = visited

for (int i = 0; i < numCourses; i++) {

if (visited[i] == 0 && hasCycle(graph, visited, i))

return false; // Found a cycle

return true;

}
 private boolean hasCycle(List<List<Integer>> graph, int[] visited, int node) {

if (visited[node] == 1) return true; // cycle

if (visited[node] == 2) return false; // already processed

visited[node] = 1; // mark as visiting

for (int neighbor : graph.get(node)) {

if (hasCycle(graph, visited, neighbor))

return true;

visited[node] = 2; // mark as visited

return false;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CourseScheduleDFS solver = new CourseScheduleDFS();

int[][] prereq1 = {{1, 0}};

int[][] prereq2 = {{1, 0}, {0, 1}};

System.out.println("Example 1: " + solver.canFinish(2, prereq1)); // true

System.out.println("Example 2: " + solver.canFinish(2, prereq2)); // false

}
🧮 Dry Run for DFS
Input: [[1,0],[0,1]]

✅
1️⃣ DFS(0): visiting → neighbor 1 → visiting → neighbor 0 → visiting → cycle detected.​
Returns false.

🧩 Comparison Table
Approach Time Space Description

BFS O(V + E) O(V + E) Topological sorting using indegree

(Best)

DFS O(V + E) O(V + E) Cycle detection via recursion

✅ Key Takeaways
●​ This problem = Directed Graph + Cycle Detection​

●​ Kahn’s Algorithm (BFS) = cleaner and non-recursive​

●​ DFS = also valid, intuitive for recursion-lovers​

●​ Pattern repeats in problems like:​

○​ Course Schedule II​

○​ Alien Dictionary​

○​ Task Dependency Resolution​

Would you like me to continue next with “Course Schedule II” (where we also return the
order of courses, not just true/false)?

Perfect 🔥
Let's move on to a classic graph + topological sorting problem — extremely
common in interviews at companies like Google, Amazon, and Meta.

🎓 Course Schedule (Leetcode #207)

🧩 Problem Statement
You are given:

●​ numCourses — total number of courses labeled 0 to numCourses - 1​

●​ prerequisites[i] = [a, b] — means to take course a, you must first take

course b​

Return true if you can finish all courses, otherwise false.

🧮 Example
Input:

numCourses = 2

prerequisites = [[1, 0]]

Output: true

Explanation:​
Take course 0 first, then 1.

Input:

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

Output: false

Explanation:​
Cycle: 0 → 1 → 0 → cannot complete.

💡 Intuition
The problem is basically:

“Can we finish all courses if there are dependency rules?”

That’s a cycle detection problem in a directed graph.

🧠 Idea
1.​ Represent courses as nodes in a directed graph.​

2.​ Add an edge b → a for each prerequisite pair [a, b].​

3.​ If there’s a cycle, we cannot complete all courses.​

4.​ Use either:​

○​ BFS (Kahn’s Algorithm) — topological sorting​

○​ DFS — detect back edges (cycles)​

🥇 Best Approach: BFS (Topological Sort / Kahn’s

Algorithm)

💻 Complete Java Code (with Comments + Driver)

import java.util.*;
public class CourseScheduleBFS {

public boolean canFinish(int numCourses, int[][] prerequisites) {

// Step 1: Build graph and indegree array

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i < numCourses; i++) graph.add(new ArrayList<>());

int[] indegree = new int[numCourses];

for (int[] pre : prerequisites) {

int course = pre[0];

int prereq = pre[1];

graph.get(prereq).add(course);

indegree[course]++;

// Step 2: Start BFS from nodes with indegree = 0

Queue<Integer> queue = new LinkedList<>();

for (int i = 0; i < numCourses; i++) {

if (indegree[i] == 0) queue.offer(i);

int completed = 0;

// Step 3: Process each course

while (!queue.isEmpty()) {
 int curr = queue.poll();

completed++;

// Decrease indegree of neighbors

for (int next : graph.get(curr)) {

indegree[next]--;

if (indegree[next] == 0) queue.offer(next);

// Step 4: Check if all courses completed

return completed == numCourses;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CourseScheduleBFS solver = new CourseScheduleBFS();

int[][] prereq1 = {{1, 0}};

int[][] prereq2 = {{1, 0}, {0, 1}};

System.out.println("Example 1: " + solver.canFinish(2, prereq1)); //

true

System.out.println("Example 2: " + solver.canFinish(2, prereq2)); //

false

}
🧪 Output
Example 1: true

Example 2: false

✅ Works perfectly.

🔍 Dry Run
Input:​
numCourses = 2, prerequisites = [[1, 0]]

Ste Queu Indegre Completed Explanation

p e e

Init [0] [0, 1] 0 Start with no prereq

1 [1] [0, 0] 1 Take 0, unlock 1

2 [] [0, 0] 2 Take 1

✅ Completed all → return true.

Cycle Example:​
[[1, 0], [0, 1]]

Ste Queu Indegre Completed

p e e
 Init [] [1, 1] 0

No node has indegree 0 → can’t start any course → false.

⏱️ Complexity
Metric Value Reason

Time O(V + E) Process all nodes and edges

once

Space O(V + E) Graph + queue

🥈 Alternate Approach: DFS (Cycle Detection)

💻 Code (DFS)
import java.util.*;

public class CourseScheduleDFS {

public boolean canFinish(int numCourses, int[][] prerequisites) {

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i < numCourses; i++) graph.add(new ArrayList<>());

for (int[] pre : prerequisites) {

 graph.get(pre[1]).add(pre[0]);

int[] visited = new int[numCourses];

// 0 = unvisited, 1 = visiting, 2 = visited

for (int i = 0; i < numCourses; i++) {

if (visited[i] == 0 && hasCycle(graph, visited, i))

return false; // Found a cycle

return true;

private boolean hasCycle(List<List<Integer>> graph, int[] visited, int

node) {

if (visited[node] == 1) return true; // cycle

if (visited[node] == 2) return false; // already processed

visited[node] = 1; // mark as visiting

for (int neighbor : graph.get(node)) {

if (hasCycle(graph, visited, neighbor))

return true;

visited[node] = 2; // mark as visited

 return false;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CourseScheduleDFS solver = new CourseScheduleDFS();

int[][] prereq1 = {{1, 0}};

int[][] prereq2 = {{1, 0}, {0, 1}};

System.out.println("Example 1: " + solver.canFinish(2, prereq1)); //

true

System.out.println("Example 2: " + solver.canFinish(2, prereq2)); //

false

🧮 Dry Run for DFS

Input: [[1,0],[0,1]]

✅
1️⃣ DFS(0): visiting → neighbor 1 → visiting → neighbor 0 → visiting → cycle detected.​
Returns false.

🧩 Comparison Table
Approach Time Space Description
 BFS O(V + E) O(V + E) Topological sorting using indegree
(Best)

DFS O(V + E) O(V + E) Cycle detection via recursion

✅ Key Takeaways
●​ This problem = Directed Graph + Cycle Detection​

●​ Kahn’s Algorithm (BFS) = cleaner and non-recursive​

●​ DFS = also valid, intuitive for recursion-lovers​

●​ Pattern repeats in problems like:​

○​ Course Schedule II​

○​ Alien Dictionary​

○​ Task Dependency Resolution​

Perfect 😎 — now we’ll extend the previous problem to Course Schedule II, which is
basically “Course Schedule” + “Return the order of courses.”

This is one of the most common topological sorting problems asked in interviews at
FAANG companies.

🎓 Course Schedule II (Leetcode #210)

🧩 Problem Statement
You are given:
 ●​ An integer numCourses — total number of courses labeled 0 to numCourses - 1.​

●​ An array prerequisites[i] = [a, b] — meaning to take course a, you must

first take course b.​

Return an ordering of courses that you can take to finish all courses.​
If it’s impossible (i.e., there’s a cycle), return an empty array.

🧮 Example 1
Input:

numCourses = 2

prerequisites = [[1, 0]]

Output: [0, 1]​

Explanation: Take 0 → then 1.

🧮 Example 2
Input:

numCourses = 4

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

Output: [0, 1, 2, 3] or [0, 2, 1, 3]​

Both valid.

🧮 Example 3
Input:

numCourses = 2

prerequisites = [[1, 0], [0, 1]]

Output: []​
Cycle → impossible to complete all.

💡 Intuition
This is the same as Course Schedule I, except:

●​ Instead of checking if it’s possible,​

●​ we must return a valid order of taking courses.​

✅ Topological sorting naturally provides this order.

🥇 Best Approach: BFS (Kahn’s Algorithm)

💻 Complete Java Code (with Comments + Driver)
import java.util.*;

public class CourseScheduleII_BFS {

public int[] findOrder(int numCourses, int[][] prerequisites) {

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i < numCourses; i++)

graph.add(new ArrayList<>());

int[] indegree = new int[numCourses];

for (int[] pre : prerequisites) {

int course = pre[0], prereq = pre[1];

graph.get(prereq).add(course);
 indegree[course]++;

Queue<Integer> queue = new LinkedList<>();

for (int i = 0; i < numCourses; i++) {

if (indegree[i] == 0) queue.offer(i);

int[] order = new int[numCourses];

int idx = 0;

while (!queue.isEmpty()) {

int curr = queue.poll();

order[idx++] = curr;

for (int next : graph.get(curr)) {

indegree[next]--;

if (indegree[next] == 0)

queue.offer(next);

// If not all courses are processed, cycle exists

if (idx != numCourses) return new int[0];

return order;
 }

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CourseScheduleII_BFS solver = new CourseScheduleII_BFS();

int[][] prereq1 = {{1, 0}};

int[][] prereq2 = {{1, 0}, {2, 0}, {3, 1}, {3, 2}};

int[][] prereq3 = {{1, 0}, {0, 1}};

System.out.println("Example 1: " +
Arrays.toString(solver.findOrder(2, prereq1))); // [0,1]

System.out.println("Example 2: " +
Arrays.toString(solver.findOrder(4, prereq2))); // [0,1,2,3] or [0,2,1,3]

System.out.println("Example 3: " +
Arrays.toString(solver.findOrder(2, prereq3))); // []

🧪 Output
Example 1: [0, 1]

Example 2: [0, 1, 2, 3]

Example 3: []

✅ Works perfectly.

🧮 Dry Run (Example 2)

Input:

numCourses = 4

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

Graph:

0 → 1, 2

1→3

2→3

3 → []

Indegree:

0:0, 1:1, 2:1, 3:2

Ste Queu Order Updated Explanation

p e indegrees

Init [0] [] [0,1,1,2] 0 has no prereqs

1 [1,2] [0] [0,0,0,2] Taking 0 unlocks 1 & 2

2 [2,3] [0,1] [0,0,0,1] Taking 1 unlocks 3

3 [3] [0,1,2] [0,0,0,0] Taking 2 unlocks 3

4 [] [0,1,2,3] [0,0,0,0] Done ✅

✅ Order = [0,1,2,3]
⏱️ Complexity
Metric Value Explanation

Time O(V + E) Each node and edge processed

once

Space O(V + E) Graph, indegree, queue

🥈 Alternate Approach: DFS (Topological Sort)

This approach uses post-order DFS — push nodes after exploring all children.

If a cycle is detected, return an empty array.

💻 DFS Code
import java.util.*;

public class CourseScheduleII_DFS {

List<List<Integer>> graph;

int[] visited; // 0 = unvisited, 1 = visiting, 2 = visited

Stack<Integer> stack;

boolean hasCycle = false;

public int[] findOrder(int numCourses, int[][] prerequisites) {

graph = new ArrayList<>();

 for (int i = 0; i < numCourses; i++)

graph.add(new ArrayList<>());

for (int[] pre : prerequisites)

graph.get(pre[1]).add(pre[0]);

visited = new int[numCourses];

stack = new Stack<>();

for (int i = 0; i < numCourses; i++) {

if (visited[i] == 0)

dfs(i);

if (hasCycle) return new int[0];

int[] order = new int[numCourses];

int idx = 0;

while (!stack.isEmpty())

order[idx++] = stack.pop();

return order;

private void dfs(int node) {

if (hasCycle) return;
 if (visited[node] == 1) { // cycle

hasCycle = true;

return;

if (visited[node] == 2) return; // already processed

visited[node] = 1; // mark as visiting

for (int next : graph.get(node))

dfs(next);

visited[node] = 2; // mark as done

stack.push(node); // add to order

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CourseScheduleII_DFS solver = new CourseScheduleII_DFS();

int[][] prereq = {{1, 0}, {2, 0}, {3, 1}, {3, 2}};

System.out.println("Order (DFS): " +

Arrays.toString(solver.findOrder(4, prereq)));

}
🧩 Comparison Table
Approach Time Space Description

BFS O(V + E) O(V + E) Kahn’s Algorithm (level by level)

(Best)

DFS O(V + E) O(V + E) Post-order traversal (stack for

order)

✅ Key Takeaways
●​ Course Schedule I → detect if cycle exists​

●​ Course Schedule II → produce topological order​

●​ Kahn’s Algorithm (BFS) = best for iterative, easy implementation​

●​ DFS = elegant for recursion + stack-based topological sort​

●​ Real-world use:​

○​ Task scheduling​

○​ Build order in compilers​

○​ Dependency resolution​

Awesome 🚀 ​
Now let’s tackle Graph Valid Tree, another super common graph problem that tests your
understanding of cycles, connectivity, and graph traversal (DFS / BFS / Union-Find).

🌳 Graph Valid Tree (Leetcode #261)

🧩 Problem Statement
You are given:

●​ n — number of nodes (labeled 0 to n-1)​

●​ An array edges where edges[i] = [a, b] represents an undirected edge

between nodes a and b.​

Return true if the given graph is a valid tree, otherwise false.

⚙️ Definition of a Tree
A graph is a tree if:

1.​ It is connected → all nodes are reachable from any node​

2.​ It has no cycles​

🧠 Mathematically, for n nodes, a tree must have exactly n - 1 edges.

🧮 Example 1
Input:

n=5

edges = [[0,1], [0,2], [0,3], [1,4]]

Output: true

✅ Connected and no cycles.

🧮 Example 2
Input:
n=5

edges = [[0,1], [1,2], [2,3], [1,3], [1,4]]

Output: false

❌ There’s a cycle between 1–2–3–1.

💡 Intuition
We just need to ensure:

●​ The graph has n - 1 edges (necessary condition for a tree)​

●​ It is fully connected (only one connected component)​

●​ No cycles (i.e., no node visited twice in one traversal)​

We can check this using either:

1.​ DFS / BFS traversal​

2.​ Union-Find (Disjoint Set Union) → most efficient and elegant.​

🥇 Best Approach: Union-Find (Disjoint Set Union)

Union-Find helps detect cycles efficiently while merging connected components.

💻 Complete Java Code (with Comments + Driver)

import java.util.*;

public class GraphValidTree_UnionFind {

public boolean validTree(int n, int[][] edges) {

// A tree must have exactly n - 1 edges

if (edges.length != n - 1)

return false;

// Initialize parent array for Union-Find

int[] parent = new int[n];

for (int i = 0; i < n; i++) parent[i] = i;

// Union-Find: connect edges

for (int[] edge : edges) {

int a = edge[0], b = edge[1];

int parentA = find(parent, a);

int parentB = find(parent, b);

// If two nodes already have the same parent → cycle

if (parentA == parentB)

return false;

// Union

parent[parentA] = parentB;

// All edges processed, no cycle found

return true;
 }

private int find(int[] parent, int node) {

if (parent[node] != node)

parent[node] = find(parent, parent[node]); // Path compression

return parent[node];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

GraphValidTree_UnionFind solver = new GraphValidTree_UnionFind();

int[][] edges1 = {{0,1}, {0,2}, {0,3}, {1,4}};

int[][] edges2 = {{0,1}, {1,2}, {2,3}, {1,3}, {1,4}};

System.out.println("Example 1: " + solver.validTree(5, edges1)); //

true

System.out.println("Example 2: " + solver.validTree(5, edges2)); //

false

🧪 Output
Example 1: true

Example 2: false
✅ Works perfectly.

🔍 Dry Run (Example 1)

n = 5, edges = [[0,1], [0,2], [0,3], [1,4]]

Ste Edge Parent Parent After Cycle

p Before ?

1 [0,1] [0,1,2,3,4] [1,1,2,3,4] No

2 [0,2] [1,1,2,3,4] [1,1,1,3,4] No

3 [0,3] [1,1,1,3,4] [1,1,1,1,4] No

4 [1,4] [1,1,1,1,4] [1,1,1,1,1] No

✅ All merged → 1 connected component, no cycles → valid tree.

⏱️ Complexity
Metric Value Explanation

Time O(E × α(V)) α(V) ≈ constant (inverse Ackermann)

Space O(V) Parent array

🥈 Alternate Approach: DFS (Cycle + Connectivity
Check)

💻 DFS Code
import java.util.*;

public class GraphValidTree_DFS {

public boolean validTree(int n, int[][] edges) {

if (edges.length != n - 1)

return false;

// Build adjacency list

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i < n; i++)

graph.add(new ArrayList<>());

for (int[] e : edges) {

graph.get(e[0]).add(e[1]);

graph.get(e[1]).add(e[0]);

boolean[] visited = new boolean[n];

// If DFS detects a cycle → false

if (hasCycle(graph, visited, 0, -1))

 return false;

// Check if all nodes visited (connected)

for (boolean v : visited)

if (!v) return false;

return true;

private boolean hasCycle(List<List<Integer>> graph, boolean[] visited,

int node, int parent) {

visited[node] = true;

for (int neighbor : graph.get(node)) {

if (neighbor == parent) continue;

if (visited[neighbor] || hasCycle(graph, visited, neighbor,

node))

return true;

return false;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

GraphValidTree_DFS solver = new GraphValidTree_DFS();

 int[][] edges1 = {{0,1}, {0,2}, {0,3}, {1,4}};

int[][] edges2 = {{0,1}, {1,2}, {2,3}, {1,3}, {1,4}};

System.out.println("Example 1 (DFS): " + solver.validTree(5,

edges1)); // true

System.out.println("Example 2 (DFS): " + solver.validTree(5,

edges2)); // false

🧩 Comparison Table
Approach Time Spac Description
e

Union-Find (Best) O(V) O(V) Detects cycles and connectivity

fast

DFS O(V + E) O(V) Simple to code, intuitive

BFS O(V + E) O(V) Same logic as DFS but iterative

✅ Key Takeaways
●​ A tree must have:​

○​ Exactly n - 1 edges​

○​ No cycles​

○​ Full connectivity​
 ●​ Union-Find is best for detecting cycles efficiently.​

●​ DFS/BFS is easier conceptually and works well for small graphs.​

●​ Real-world analogy:​

○​ Checking if a computer network is fully connected without loops.​

Perfect 💪 ​
Now we’ll move to a closely related and fundamental problem —​
basically a generalized version of the previous one (Graph Valid Tree).

🌐 Number of Connected Components in

an Undirected Graph (Leetcode #323)

🧩 Problem Statement
You are given:

●​ An integer n representing the number of nodes labeled from 0 to n - 1.​

●​ An array edges, where edges[i] = [a, b] indicates that there is an undirected

edge between nodes a and b.​

Return the number of connected components in the graph.

🧮 Example 1
Input:

n=5

edges = [[0,1], [1,2], [3,4]]

Output:

Explanation:

●​ Component 1: {0, 1, 2}​

●​ Component 2: {3, 4}​

🧮 Example 2
Input:

n=5

edges = [[0,1], [1,2], [2,3], [3,4]]

Output:

Explanation:​
All nodes are connected → 1 component.

💡 Intuition
Each connected component can be explored using:

●​ DFS / BFS → traverse each connected region once, or​

●​ Union-Find (Disjoint Set) → merge connected nodes.​

Every time we find a new “unvisited” node, that’s the start of a new component.
🥇 Best Approach: Union-Find (Disjoint Set Union)
💻 Complete Java Code (with Comments + Driver)
import java.util.*;

public class NumberOfConnectedComponents_UnionFind {

public int countComponents(int n, int[][] edges) {

int[] parent = new int[n];

int[] rank = new int[n];

for (int i = 0; i < n; i++) parent[i] = i;

int components = n;

for (int[] edge : edges) {

int a = edge[0];

int b = edge[1];

if (union(parent, rank, a, b))

components--; // merged → reduce component count

return components;

}
private int find(int[] parent, int x) {

if (parent[x] != x)

parent[x] = find(parent, parent[x]); // Path compression

return parent[x];

private boolean union(int[] parent, int[] rank, int a, int b) {

int rootA = find(parent, a);

int rootB = find(parent, b);

if (rootA == rootB)

return false; // already connected

// Union by rank optimization

if (rank[rootA] < rank[rootB]) {

parent[rootA] = rootB;

} else if (rank[rootB] < rank[rootA]) {

parent[rootB] = rootA;

} else {

parent[rootB] = rootA;

rank[rootA]++;

return true;

}
 // ---------------- DRIVER ----------------

public static void main(String[] args) {

NumberOfConnectedComponents_UnionFind solver = new

NumberOfConnectedComponents_UnionFind();

int[][] edges1 = {{0,1}, {1,2}, {3,4}};

int[][] edges2 = {{0,1}, {1,2}, {2,3}, {3,4}};

System.out.println("Example 1: " + solver.countComponents(5,

edges1)); // 2

System.out.println("Example 2: " + solver.countComponents(5,

edges2)); // 1

🧪 Output
Example 1: 2

Example 2: 1

✅ Works perfectly.

🔍 Dry Run (Example 1)

n = 5, edges = [[0,1], [1,2], [3,4]]

Initially:​
parent = [0,1,2,3,4], components = 5
 Ste Edge Parent After Component Comment
p s

1 [0,1] [0,0,2,3,4] 4 merged

0–1

2 [1,2] [0,0,0,3,4] 3 merged 2

3 [3,4] [0,0,0,3,3] 2 merged

3–4

✅ Final count = 2

⏱️ Complexity
Metric Value Explanation

Time O(E × α(V)) α(V) ≈ constant

Space O(V) Parent + rank

arrays

🥈 Alternate Approach: DFS / BFS

Use graph traversal to mark visited nodes.

💻 DFS Code (Alternative)

import java.util.*;
public class NumberOfConnectedComponents_DFS {

public int countComponents(int n, int[][] edges) {

List<List<Integer>> graph = new ArrayList<>();

for (int i = 0; i < n; i++)

graph.add(new ArrayList<>());

for (int[] e : edges) {

graph.get(e[0]).add(e[1]);

graph.get(e[1]).add(e[0]);

boolean[] visited = new boolean[n];

int components = 0;

for (int i = 0; i < n; i++) {

if (!visited[i]) {

dfs(graph, visited, i);

components++;

return components;

}
 private void dfs(List<List<Integer>> graph, boolean[] visited, int node)
{

visited[node] = true;

for (int neighbor : graph.get(node)) {

if (!visited[neighbor])

dfs(graph, visited, neighbor);

// ---------------- DRIVER ----------------

public static void main(String[] args) {

NumberOfConnectedComponents_DFS solver = new

NumberOfConnectedComponents_DFS();

int[][] edges1 = {{0,1}, {1,2}, {3,4}};

int[][] edges2 = {{0,1}, {1,2}, {2,3}, {3,4}};

System.out.println("Example 1 (DFS): " + solver.countComponents(5,

edges1)); // 2

System.out.println("Example 2 (DFS): " + solver.countComponents(5,

edges2)); // 1

🧩 Comparison Table
 Approach Time Space Description

Union-Find (Best) O(V + E) O(V) Most efficient, ideal for large graphs

DFS / BFS O(V + E) O(V + E) Simple and intuitive

✅ Key Takeaways
●​ Tree = 1 connected component with no cycles.​

●​ This problem = count all such connected components.​

●​ Union-Find is best for efficiency and reusability.​

●​ Common interview question in Google, Amazon, and Meta.​

Awesome 😎 ​
Now we’re moving to one of the most elegant Union-Find problems —​
a direct application of detecting cycles in an undirected graph.

🔁 Redundant Connection (Leetcode

#684)

🧩 Problem Statement
You are given a graph that started as a tree with n nodes labeled 1 to n.​
Then, one extra edge was added, creating a cycle.

Return the edge that can be removed so that the resulting graph is again a tree.​
If there are multiple answers, return the edge that appears last in the input.
🧮 Example 1
Input:

edges = [[1,2], [1,3], [2,3]]

Output: [2,3]

Explanation:​
Adding [2,3] creates a cycle (1–2–3–1).​
Removing it restores the tree.

🧮 Example 2
Input:

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

Output: [1,4]

Explanation:​
Edge [1,4] introduces a cycle (1–2–3–4–1).

💡 Intuition
The problem gives a graph that’s almost a tree — meaning:

●​ It’s connected​

●​ Has exactly one cycle​

Our task is to find the edge responsible for that cycle.

👉 This is a perfect scenario for Union-Find (Disjoint Set).

🧠 Approach (Union-Find)
1.​ Initialize each node as its own parent.​

2.​ For each edge (u, v):​

○​ If u and v already share the same root, this edge forms a cycle → return it.​

○​ Otherwise, union the two sets.​

3.​ If no cycle, return an empty array (though problem guarantees one exists).​

🥇 Best Approach: Union-Find (Cycle Detection)

💻 Complete Java Code (with Comments + Driver)
import java.util.*;

public class RedundantConnection_UnionFind {

public int[] findRedundantConnection(int[][] edges) {

int n = edges.length;

int[] parent = new int[n + 1];

int[] rank = new int[n + 1];

for (int i = 1; i <= n; i++)

parent[i] = i;

for (int[] edge : edges) {

int a = edge[0], b = edge[1];

 // If both nodes have the same parent → cycle found

if (!union(parent, rank, a, b))

return edge;

return new int[0];

private int find(int[] parent, int x) {

if (parent[x] != x)

parent[x] = find(parent, parent[x]); // Path compression

return parent[x];

private boolean union(int[] parent, int[] rank, int a, int b) {

int rootA = find(parent, a);

int rootB = find(parent, b);

if (rootA == rootB)

return false; // Already connected → cycle

// Union by rank

if (rank[rootA] < rank[rootB])

parent[rootA] = rootB;

else if (rank[rootB] < rank[rootA])

 parent[rootB] = rootA;

else {

parent[rootB] = rootA;

rank[rootA]++;

return true;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

RedundantConnection_UnionFind solver = new

RedundantConnection_UnionFind();

int[][] edges1 = {{1,2}, {1,3}, {2,3}};

int[][] edges2 = {{1,2}, {2,3}, {3,4}, {1,4}, {1,5}};

System.out.println("Example 1: " +
Arrays.toString(solver.findRedundantConnection(edges1))); // [2,3]

System.out.println("Example 2: " +
Arrays.toString(solver.findRedundantConnection(edges2))); // [1,4]

🧪 Output
Example 1: [2, 3]

Example 2: [1, 4]
✅ Works perfectly.

🔍 Dry Run (Example 2)

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

Ste Edge Parent Cycle Parent After

p Before ?

1 [1,2] [1,2,3,4,5] ❌ 1–2 merged

2 [2,3] [1,1,3,4,5] ❌ 1–2–3 merged

3 [3,4] [1,1,1,4,5] ❌ 1–2–3–4 merged

4 [1,4] [1,1,1,1,5] ✅ cycle detected → return [1,4]

✅ Answer = [1,4]

⏱️ Complexity
Metric Value Explanation

Time O(N × α(N)) α(N) ≈ constant (inverse Ackermann)

Space O(N) Parent and rank arrays

🥈 Alternate Approach: DFS Cycle Detection
We can simulate the graph and check for cycles manually.

💻 DFS Code
import java.util.*;

public class RedundantConnection_DFS {

public int[] findRedundantConnection(int[][] edges) {

Map<Integer, List<Integer>> graph = new HashMap<>();

for (int[] edge : edges) {

int a = edge[0], b = edge[1];

Set<Integer> visited = new HashSet<>();

if (graph.containsKey(a) && graph.containsKey(b) && dfs(graph, a,

b, visited))

return edge; // cycle found

graph.computeIfAbsent(a, k -> new ArrayList<>()).add(b);

graph.computeIfAbsent(b, k -> new ArrayList<>()).add(a);

return new int[0];

}
 private boolean dfs(Map<Integer, List<Integer>> graph, int src, int
target, Set<Integer> visited) {

if (src == target) return true;

visited.add(src);

for (int neighbor : graph.getOrDefault(src, new ArrayList<>())) {

if (!visited.contains(neighbor) && dfs(graph, neighbor, target,

visited))

return true;

return false;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

RedundantConnection_DFS solver = new RedundantConnection_DFS();

int[][] edges1 = {{1,2}, {1,3}, {2,3}};

int[][] edges2 = {{1,2}, {2,3}, {3,4}, {1,4}, {1,5}};

System.out.println("Example 1 (DFS): " +

Arrays.toString(solver.findRedundantConnection(edges1))); // [2,3]

System.out.println("Example 2 (DFS): " +

Arrays.toString(solver.findRedundantConnection(edges2))); // [1,4]

}
🧩 Comparison Table
Approach Time Spac Description
e

Union-Find (Best) O(N) O(N) Most efficient and elegant

DFS O(N²) O(N) Intuitive but slower for large inputs

✅ Key Takeaways
●​ This problem is a cycle detection in an undirected graph.​

●​ Union-Find is the ideal tool — detects cycles efficiently.​

●​ The same concept powers:​

○​ Graph Valid Tree​

○​ Number of Connected Components​

○​ Minimum Spanning Tree (Kruskal’s Algorithm)​

Perfect 🔥
Now we’re entering the Word Ladder (Leetcode #127) — one of the most famous BFS
problems that tests graph + string manipulation together.

🧩 Word Ladder (Leetcode #127)

🧠 Problem Statement
A transformation sequence from word beginWord to endWord using a dictionary word
list is one where:

●​ Only one letter can be changed at a time.​

●​ Each transformed word must exist in the word list.​

Return the length of the shortest transformation sequence from beginWord to

endWord.​
If no such sequence exists, return 0.

🧮 Example 1
Input:

beginWord = "hit"

endWord = "cog"

wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation:

"hit" → "hot" → "dot" → "dog" → "cog"

Each transformation changes one letter and exists in wordList.

🧮 Example 2
Input:

beginWord = "hit"

endWord = "cog"

wordList = ["hot","dot","dog","lot","log"]
Output: 0​
"cog" not in the word list → no valid transformation.

💡 Intuition
We can think of each word as a node in a graph, where there’s an edge between two nodes
if they differ by exactly one character.

We need the shortest path from beginWord → endWord.

👉 That’s a Breadth-First Search (BFS) problem.

🧠 Approach — BFS (Best Approach)

1.​ Convert the wordList into a Set for O(1) lookups.​

2.​ Use a queue for BFS traversal.​

3.​ For each word, try replacing each letter (a–z) to generate neighbors.​

4.​ If a neighbor exists in the set:​

○​ Add to queue​

○​ Remove from set (visited)​

5.​ Return the BFS level (distance) when endWord is found.​

🥇 Best Approach: BFS (Shortest Transformation)

💻 Complete Java Code (With Comments + Driver)
import java.util.*;
public class WordLadder_BFS {

public int ladderLength(String beginWord, String endWord, List<String>

wordList) {

Set<String> wordSet = new HashSet<>(wordList);

if (!wordSet.contains(endWord))

return 0;

Queue<String> queue = new LinkedList<>();

queue.offer(beginWord);

int steps = 1;

while (!queue.isEmpty()) {

int size = queue.size();

// Process all words in the current BFS level

for (int i = 0; i < size; i++) {

String word = queue.poll();

if (word.equals(endWord))

return steps;

char[] arr = word.toCharArray();

// Try changing each letter

for (int j = 0; j < arr.length; j++) {

 char original = arr[j];

for (char c = 'a'; c <= 'z'; c++) {

if (c == original) continue;

arr[j] = c;

String newWord = new String(arr);

// If new word is in dictionary

if (wordSet.contains(newWord)) {

queue.offer(newWord);

wordSet.remove(newWord); // mark visited

arr[j] = original; // restore

steps++;

return 0;

// ---------------- DRIVER ----------------

 public static void main(String[] args) {

WordLadder_BFS solver = new WordLadder_BFS();

List<String> wordList1 =
Arrays.asList("hot","dot","dog","lot","log","cog");

List<String> wordList2 =
Arrays.asList("hot","dot","dog","lot","log");

System.out.println("Example 1: " + solver.ladderLength("hit", "cog",

wordList1)); // 5

System.out.println("Example 2: " + solver.ladderLength("hit", "cog",

wordList2)); // 0

🧪 Output
Example 1: 5

Example 2: 0

✅ Works perfectly.

🔍 Step-by-Step Dry Run (Example 1)

Input:​
beginWord = "hit", endWord = "cog"​
wordList = ["hot","dot","dog","lot","log","cog"]

BFS Progression:
 Level Queue Notes
Contents

1 hit Start

2 hot hit → hot

3 dot, lot From hot

4 dog, log From dot,

lot

5 cog From dog

✅ Found cog at level 5 → Shortest path = 5

⏱️ Complexity
Metric Value Explanation

Time O(N × L²) N = number of words, L = word length

Space O(N × L) For queue, set, and intermediate

words

🥈 Alternate Approach: Bidirectional BFS

For optimization — instead of starting BFS from one end, we can start from both
beginWord and endWord, meeting in the middle.

This reduces the search space significantly.

💻 Bidirectional BFS Code

import java.util.*;

public class WordLadder_BidirectionalBFS {

public int ladderLength(String beginWord, String endWord, List<String>

wordList) {

Set<String> wordSet = new HashSet<>(wordList);

if (!wordSet.contains(endWord))

return 0;

Set<String> beginSet = new HashSet<>();

Set<String> endSet = new HashSet<>();

Set<String> visited = new HashSet<>();

beginSet.add(beginWord);

endSet.add(endWord);

int steps = 1;

while (!beginSet.isEmpty() && !endSet.isEmpty()) {

// Always expand smaller set first (optimization)

if (beginSet.size() > endSet.size()) {

 Set<String> temp = beginSet;

beginSet = endSet;

endSet = temp;

Set<String> nextLevel = new HashSet<>();

for (String word : beginSet) {

char[] arr = word.toCharArray();

for (int i = 0; i < arr.length; i++) {

char original = arr[i];

for (char c = 'a'; c <= 'z'; c++) {

if (c == original) continue;

arr[i] = c;

String newWord = new String(arr);

if (endSet.contains(newWord))

return steps + 1;

if (wordSet.contains(newWord) &&
!visited.contains(newWord)) {

nextLevel.add(newWord);

visited.add(newWord);

}
 }

arr[i] = original;

beginSet = nextLevel;

steps++;

return 0;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

WordLadder_BidirectionalBFS solver = new

WordLadder_BidirectionalBFS();

List<String> wordList1 =
Arrays.asList("hot","dot","dog","lot","log","cog");

System.out.println("Example (Bidirectional BFS): " +

solver.ladderLength("hit", "cog", wordList1)); // 5

}
🧩 Comparison Table
Approach Time Space Remarks

Normal BFS O(N × L²) O(N × L) Easier to implement

Bidirectional BFS O(N × L) O(N) More optimized, faster in practice

✅ Key Takeaways
●​ The Word Ladder is a BFS shortest path on an implicit graph.​

●​ Each word → node, edges defined by 1-letter transformations.​

●​ Bidirectional BFS drastically speeds up search.​

●​ Commonly asked in Google, Amazon, and Microsoft interviews.​

Excellent🚀 ​
Now we move into a weighted directed graph problem — a perfect use case for Dijkstra’s
Algorithm.​
This problem tests your grasp of graph traversal with weights, priority queues, and
shortest path logic.

⚡ Network Delay Time (Leetcode #743)

🧩 Problem Statement
You are given a network of n nodes labeled from 1 to n, represented as a list of travel times
as directed edges times[i] = [u, v, w],​
where:
 ●​ u → source node​

●​ v → target node​

●​ w → time it takes for a signal to travel from u to v​

We send a signal from a given node k.

Return the minimum time it takes for all nodes to receive the signal.​
If it is impossible for all nodes to receive the signal, return -1.

🧮 Example 1
Input:

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

n=4

k=2

Output: 2

Explanation:

●​ From node 2,​

○​ signal reaches 1 in 1 unit​

○​ signal reaches 3 in 1 unit​

○​ then reaches 4 via 3 in 2 units​

→ Total = 2​

🧮 Example 2
Input:

times = [[1,2,1]]
n=2

k=1

Output: 1

🧮 Example 3
Input:

times = [[1,2,1]]

n=2

k=2

Output: -1​
Node 1 cannot be reached from 2.

💡 Intuition
We are essentially finding the shortest time to reach all nodes from a single source node.

✅
This is the Single Source Shortest Path (SSSP) problem →​
Use Dijkstra’s Algorithm (for positive weights).

🧠 Approach — Dijkstra’s Algorithm (Min-Heap)

1.​ Build an adjacency list:​
{u → [(v1, w1), (v2, w2), ...]}​

2.​ Use a PriorityQueue (min-heap) to always pick the next node with the smallest
current travel time.​

3.​ Maintain a distance array to store the shortest time to each node.​

4.​ Perform standard Dijkstra traversal until all reachable nodes are visited.​
 5.​ Return the maximum distance among all reachable nodes.​
If any node is unreachable → return -1.​

🥇 Best Approach: Dijkstra (Using Priority Queue)

💻 Complete Java Code (With Comments + Driver)
import java.util.*;

public class NetworkDelayTime_Dijkstra {

public int networkDelayTime(int[][] times, int n, int k) {

// Step 1: Build adjacency list

Map<Integer, List<int[]>> graph = new HashMap<>();

for (int[] edge : times) {

graph.computeIfAbsent(edge[0], x -> new ArrayList<>()).add(new

int[]{edge[1], edge[2]});

// Step 2: Min-heap for [time, node]

PriorityQueue<int[]> pq = new
PriorityQueue<>(Comparator.comparingInt(a -> a[0]));

pq.offer(new int[]{0, k});

// Step 3: Distance array

int[] dist = new int[n + 1];

Arrays.fill(dist, Integer.MAX_VALUE);
 dist[k] = 0;

// Step 4: Dijkstra’s algorithm

while (!pq.isEmpty()) {

int[] curr = pq.poll();

int time = curr[0];

int node = curr[1];

if (time > dist[node]) continue;

for (int[] neighbor : graph.getOrDefault(node, new

ArrayList<>())) {

int next = neighbor[0];

int weight = neighbor[1];

int newTime = time + weight;

if (newTime < dist[next]) {

dist[next] = newTime;

pq.offer(new int[]{newTime, next});

// Step 5: Find the maximum time

int maxTime = 0;

for (int i = 1; i <= n; i++) {

 if (dist[i] == Integer.MAX_VALUE)

return -1;

maxTime = Math.max(maxTime, dist[i]);

return maxTime;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

NetworkDelayTime_Dijkstra solver = new NetworkDelayTime_Dijkstra();

int[][] times1 = {{2,1,1},{2,3,1},{3,4,1}};

int[][] times2 = {{1,2,1}};

int[][] times3 = {{1,2,1}};

System.out.println("Example 1: " + solver.networkDelayTime(times1, 4,

2)); // 2

System.out.println("Example 2: " + solver.networkDelayTime(times2, 2,

1)); // 1

System.out.println("Example 3: " + solver.networkDelayTime(times3, 2,

2)); // -1

🧪 Output
Example 1: 2

Example 2: 1

Example 3: -1

✅ Works perfectly.

🔍 Dry Run (Example 1)

Input:​
times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2

Initialization:​
dist = [∞, ∞, 0, ∞, ∞]​
pq = [(0, 2)]

Ste Extracted Update dist[] Comment

p

1 (0,2) → (1,1), (1,3) [∞,1,0,1,∞] from node 2

2 (1,1) — [∞,1,0,1,∞] no outgoing

edges

3 (1,3) → (2,4) [∞,1,0,1,2] from node 3

✅ All nodes reached → max = 2

⏱️ Complexity
Metric Value Explanation
Time O(E log V) Each edge relax operation uses
PQ

Space O(V + E) Adjacency list + dist[] + PQ

🥈 Alternate Approach: Bellman-Ford Algorithm

👇
Used when edges can have negative weights​
(Not needed here, but for completeness )

💻 Bellman-Ford Code
import java.util.*;

public class NetworkDelayTime_BellmanFord {

public int networkDelayTime(int[][] times, int n, int k) {

int[] dist = new int[n + 1];

Arrays.fill(dist, Integer.MAX_VALUE);

dist[k] = 0;

for (int i = 1; i < n; i++) { // Relax edges n-1 times

for (int[] edge : times) {

int u = edge[0], v = edge[1], w = edge[2];

if (dist[u] != Integer.MAX_VALUE && dist[u] + w < dist[v])

dist[v] = dist[u] + w;

}
 }

int max = 0;

for (int i = 1; i <= n; i++) {

if (dist[i] == Integer.MAX_VALUE) return -1;

max = Math.max(max, dist[i]);

return max;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

NetworkDelayTime_BellmanFord solver = new

NetworkDelayTime_BellmanFord();

int[][] times = {{2,1,1},{2,3,1},{3,4,1}};

System.out.println("Bellman-Ford: " + solver.networkDelayTime(times,

4, 2)); // 2

🧩 Comparison Table
Approach Time Space Handles Negative Remarks
Weights?
 Dijkstra O(E log O(V + ❌ Fastest for positive
(Best) V) E) weights

Bellman-For O(V × E) O(V) ✅ Slower but more

d general

✅ Key Takeaways
●​ Dijkstra → single-source shortest path (positive weights).​

●​ Bellman-Ford → works for negative weights (but slower).​

●​ Common interview question for Google, Amazon, and Microsoft.​

●​ A must-know graph algorithm for competitive programming.​

Awesome ✈️
​
Now we move to a very elegant graph + DFS problem —​
a classic from Leetcode that tests your understanding of Eulerian paths, backtracking,
and lexicographically smallest ordering.

🧭 Reconstruct Itinerary (Leetcode #332)

🧩 Problem Statement
You are given a list of airline tickets, where tickets[i] = [from, to] represents a
flight from airport from to airport to.

●​ You must reconstruct the itinerary in order.​

●​ The itinerary must:​

 1.​ Start from "JFK".​

2.​ Use all tickets exactly once.​

3.​ Be lexicographically smallest among all possible valid itineraries.​

🧮 Example 1
Input:

tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]

Output:

["JFK","MUC","LHR","SFO","SJC"]

🧮 Example 2
Input:

tickets = [["JFK","KUL"],["JFK","NRT"],["NRT","JFK"]]

Output:

["JFK","NRT","JFK","KUL"]

💡 Intuition
●​ Each ticket = directed edge (from → to).​

●​ You must find a path that uses all edges exactly once — that’s an Eulerian Path.​
 ●​ However, because of lexicographical constraints, we must always visit the smallest
lexical destination first.​

👉 Use DFS (Depth First Search) with a min-heap (PriorityQueue) for lexical order.

🧠 Approach — DFS + Hierholzer’s Algorithm

1.​ Build an adjacency list graph:​

○​ Key: departure airport (from)​

○​ Value: min-heap of destinations (to)​

2.​ Start DFS from "JFK".​

○​ Always pick the lexicographically smallest next airport.​

○​ Recursively visit it (removing the edge each time).​

3.​ Once a node has no more outgoing flights, add it to the front of the result list
(postorder).​

This ensures all edges are used exactly once in correct order.

🥇 Best Approach: DFS + PriorityQueue

💻 Complete Java Code (With Comments + Driver)
import java.util.*;

public class ReconstructItinerary_DFS {

private LinkedList<String> itinerary;

private Map<String, PriorityQueue<String>> graph;

 public List<String> findItinerary(List<List<String>> tickets) {

graph = new HashMap<>();

itinerary = new LinkedList<>();

// Step 1: Build graph (min-heap for lexicographical order)

for (List<String> ticket : tickets) {

String from = ticket.get(0);

String to = ticket.get(1);

graph.computeIfAbsent(from, k -> new

PriorityQueue<>()).offer(to);

// Step 2: Start DFS from "JFK"

dfs("JFK");

return itinerary;

private void dfs(String airport) {

PriorityQueue<String> destinations = graph.get(airport);

while (destinations != null && !destinations.isEmpty()) {

String next = destinations.poll(); // smallest lexicographically

dfs(next);

}
 itinerary.addFirst(airport); // postorder addition

// ---------------- DRIVER ----------------

public static void main(String[] args) {

ReconstructItinerary_DFS solver = new ReconstructItinerary_DFS();

List<List<String>> tickets1 = Arrays.asList(

Arrays.asList("MUC","LHR"),

Arrays.asList("JFK","MUC"),

Arrays.asList("SFO","SJC"),

Arrays.asList("LHR","SFO")

);

List<List<String>> tickets2 = Arrays.asList(

Arrays.asList("JFK","KUL"),

Arrays.asList("JFK","NRT"),

Arrays.asList("NRT","JFK")

);

System.out.println("Example 1: " + solver.findItinerary(tickets1));

System.out.println("Example 2: " + solver.findItinerary(tickets2));

}
🧪 Output
Example 1: [JFK, MUC, LHR, SFO, SJC]

Example 2: [JFK, NRT, JFK, KUL]

✅ Works perfectly.

🔍 Dry Run (Example 2)

Tickets = [["JFK","KUL"], ["JFK","NRT"], ["NRT","JFK"]]

Graph:

JFK → [KUL, NRT]

NRT → [JFK]

DFS Steps:

Ste Current Node Action Itinerary (Reversed Building)

p

1 JFK go NRT []

2 NRT go JFK []

3 JFK go KUL []

4 KUL no outgoing [KUL]

 5 JFK no outgoing [JFK, KUL]

6 NRT no outgoing [NRT, JFK, KUL]

7 JFK done [JFK, NRT, JFK, KUL]

✅ Final Itinerary = [JFK, NRT, JFK, KUL]

⏱️ Complexity
Metric Value Explanation

Time O(E log E) Each edge inserted & polled from PQ

Space O(E + V) Graph + recursion stack

🥈 Alternate Approach — Iterative DFS (Stack)

You can also simulate recursion using a stack.

💻 Iterative Code
import java.util.*;

public class ReconstructItinerary_Iterative {

public List<String> findItinerary(List<List<String>> tickets) {

 Map<String, PriorityQueue<String>> graph = new HashMap<>();

for (List<String> ticket : tickets) {

graph.computeIfAbsent(ticket.get(0), k -> new

PriorityQueue<>()).offer(ticket.get(1));

LinkedList<String> result = new LinkedList<>();

Stack<String> stack = new Stack<>();

stack.push("JFK");

while (!stack.isEmpty()) {

String top = stack.peek();

if (graph.containsKey(top) && !graph.get(top).isEmpty()) {

stack.push(graph.get(top).poll());

} else {

result.addFirst(stack.pop());

return result;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

 ReconstructItinerary_Iterative solver = new
ReconstructItinerary_Iterative();

List<List<String>> tickets = Arrays.asList(

Arrays.asList("MUC","LHR"),

Arrays.asList("JFK","MUC"),

Arrays.asList("SFO","SJC"),

Arrays.asList("LHR","SFO")

);

System.out.println("Iterative: " + solver.findItinerary(tickets));

🧩 Comparison Table
Approach Time Space Remarks

Recursive DFS O(E log E) O(E + V) Clean, simple, elegant

(Best)

Iterative DFS O(E log E) O(E) Avoids recursion limit issues

✅ Key Takeaways
●​ This problem is a directed Eulerian path reconstruction.​
 ●​ Always use lexical min-heap to ensure lexicographically smallest result.​

●​ Postorder DFS ensures correct traversal order.​

●​ Elegant and often asked by Google, Amazon, Meta.​

Perfect ⚡
​
Next up — a graph + MST (Minimum Spanning Tree) problem — one of the most elegant
uses of Kruskal’s algorithm + Union-Find.

🏗️ Min Cost to Connect All Points

(Leetcode #1584)

🧩 Problem Statement
You are given an array points where points[i] = [xi, yi] represents a point on the
2D plane.

The cost to connect two points (xi, yi) and (xj, yj) is their Manhattan distance:

[​
|xi - xj| + |yi - yj|​
]

You must connect all points with the minimum total cost.​
A connection between any two points is allowed.

🧮 Example 1
Input:

points = [[0,0],[2,2],[3,10],[5,2],[7,0]]

Output:
20

Explanation:

The minimum cost to connect all points is 20.

One possible way:

0-1 (4), 1-3 (3), 3-4 (4), 1-2 (9) → 4+3+4+9=20

🧮 Example 2
Input:

points = [[3,12],[-2,5],[-4,1]]

Output:

18

💡 Intuition
You can connect any point to any other, so this forms a complete graph:

●​ Each point = node​

●​ Each edge = connection between two points​

●​ Weight = Manhattan distance​

We need to connect all nodes with minimum cost → that’s a Minimum Spanning Tree
(MST) problem.

🧠 Approach 1 — Kruskal’s Algorithm (Best Approach)

 1.​ Compute all possible edges (u, v, cost) between points.​

2.​ Sort all edges by cost.​

3.​ Use Union-Find (Disjoint Set) to connect points while avoiding cycles.​

4.​ Keep adding smallest edges until all points are connected.​

⚙️ Steps
1.​ Build edge list (O(N²))​

2.​ Sort edges (O(E log E))​

3.​ Iterate with Union-Find (O(E α(N)))​

🥇 Best Approach: Kruskal’s Algorithm + Union-Find

💻 Complete Java Code (With Comments + Driver)
import java.util.*;

public class MinCostConnectPoints_Kruskal {

// ---------------- Union-Find (Disjoint Set) ----------------

static class UnionFind {

int[] parent, rank;

int count;

UnionFind(int n) {

parent = new int[n];

 rank = new int[n];

count = n;

for (int i = 0; i < n; i++) parent[i] = i;

int find(int x) {

if (x != parent[x])

parent[x] = find(parent[x]);

return parent[x];

boolean union(int x, int y) {

int rootX = find(x);

int rootY = find(y);

if (rootX == rootY) return false;

if (rank[rootX] > rank[rootY]) parent[rootY] = rootX;

else if (rank[rootX] < rank[rootY]) parent[rootX] = rootY;

else {

parent[rootY] = rootX;

rank[rootX]++;

count--;

return true;
 }

// ---------------- Main Logic ----------------

public int minCostConnectPoints(int[][] points) {

int n = points.length;

List<int[]> edges = new ArrayList<>();

// Step 1: Build all possible edges (complete graph)

for (int i = 0; i < n; i++) {

for (int j = i + 1; j < n; j++) {

int dist = Math.abs(points[i][0] - points[j][0]) +

Math.abs(points[i][1] - points[j][1]);

edges.add(new int[]{i, j, dist});

// Step 2: Sort edges by cost

edges.sort(Comparator.comparingInt(a -> a[2]));

// Step 3: Kruskal's MST

UnionFind uf = new UnionFind(n);

int cost = 0;

for (int[] edge : edges) {

int u = edge[0], v = edge[1], w = edge[2];

 if (uf.union(u, v)) {

cost += w;

if (uf.count == 1) break; // all connected

return cost;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

MinCostConnectPoints_Kruskal solver = new

MinCostConnectPoints_Kruskal();

int[][] points1 = {{0,0},{2,2},{3,10},{5,2},{7,0}};

int[][] points2 = {{3,12}, {-2,5}, {-4,1}};

System.out.println("Example 1: " +
solver.minCostConnectPoints(points1)); // 20

System.out.println("Example 2: " +
solver.minCostConnectPoints(points2)); // 18

🧪 Output
Example 1: 20
Example 2: 18

✅ Works perfectly.

🔍 Dry Run (Example 1)

points = [[0,0],[2,2],[3,10],[5,2],[7,0]]

Build edges (partial):​

​
(0,1)=4, (1,3)=3, (3,4)=4, (1,2)=9 ...

1.​

Sort by weight:​
​
[ (1,3)=3, (0,1)=4, (3,4)=4, (1,2)=9 ... ]

2.​

Add edges until all connected:​

​
Add (1,3): cost=3

Add (0,1): cost=7

Add (3,4): cost=11

Add (1,2): cost=20

3.​

✅ Minimum Total = 20

⏱️ Complexity
Metric Value Explanation

Time O(N² log N) Build all edges (N²), sort them

 Space O(N²) Store all edges

🥈 Alternate Approach — Prim’s Algorithm (Optimized)

Instead of generating all edges (O(N² log N)), Prim’s algorithm builds the MST
incrementally using a min-heap, which is more efficient for dense graphs.

💻 Prim’s Algorithm Code

import java.util.*;

public class MinCostConnectPoints_Prim {

public int minCostConnectPoints(int[][] points) {

int n = points.length;

boolean[] visited = new boolean[n];

int edgesUsed = 0, cost = 0;

int[] minDist = new int[n];

Arrays.fill(minDist, Integer.MAX_VALUE);

minDist[0] = 0;

while (edgesUsed < n) {

int curr = -1;

// Pick unvisited node with smallest edge

 for (int i = 0; i < n; i++) {

if (!visited[i] && (curr == -1 || minDist[i] <

minDist[curr])) {

curr = i;

visited[curr] = true;

cost += minDist[curr];

edgesUsed++;

// Update min distances for remaining nodes

for (int next = 0; next < n; next++) {

if (!visited[next]) {

int dist = Math.abs(points[curr][0] - points[next][0]) +

Math.abs(points[curr][1] - points[next][1]);

minDist[next] = Math.min(minDist[next], dist);

return cost;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

 MinCostConnectPoints_Prim solver = new MinCostConnectPoints_Prim();

int[][] points1 = {{0,0},{2,2},{3,10},{5,2},{7,0}};

System.out.println("Prim’s MST Cost: " +

solver.minCostConnectPoints(points1)); // 20

🧩 Comparison Table
Approach Time Spac Remarks
e

Kruskal’s + Union-Find O(N² log N) O(N²) Intuitive, edge-based

Prim’s Algorithm O(N²) O(N) Faster for dense

graphs

✅ Key Takeaways
●​ Both Kruskal and Prim solve Minimum Spanning Tree problems.​

●​ Use Kruskal when it’s easy to precompute edges.​

●​ Use Prim for dense graphs (like this one).​

●​ Classic in Google, Amazon, and Microsoft interviews.​

🔥 Great — now let’s tackle a graph + grid + Dijkstra style problem that blends
pathfinding and priority queues beautifully.

🌊 Swim in Rising Water (Leetcode #778)

🧩 Problem Statement
You are given an n x n integer grid grid where each cell represents the elevation at that
point.

You start at the top-left cell (0,0) and want to reach the bottom-right cell (n-1,n-1).

At time t, you can enter any cell whose elevation ≤ t.​

You can move in 4 directions (up, down, left, right).

Return the minimum time t such that you can reach the bottom-right cell.

🧮 Example 1
Input:

grid = [

[0,2],

[1,3]

Output:

Explanation:

●​ At time t=0, you can start at (0,0).​

 ●​ t=1: You can move to (1,0).​

●​ t=2: Cannot move right — blocked by elevation 3.​

●​ t=3: Path opens → (0,0) → (1,0) → (1,1)​

✅ Minimum time = 3

🧮 Example 2
Input:

grid = [

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

[24,23,22,21,5],

[12,13,14,15,16],

[11,17,18,19,20],

[10,9,8,7,6]

Output:

16

💡 Intuition
Each cell becomes “swimmable” only when the water level (time t) is ≥ elevation.

We must find a path from start → end such that the maximum elevation encountered
along the path is minimized.

👉 That’s a Minimum Maximum Path Problem,​

which can be solved using Dijkstra’s Algorithm (Min-Heap).
🧠 Approach — Dijkstra (Best Approach)
1.​ Use a PriorityQueue to always expand the lowest elevation cell you can reach next.​

2.​ Each step:​

○​ Take the lowest elevation cell.​

○​ Track the max elevation seen so far (since you need at least that much water
to reach it).​

○​ Push all valid 4-direction neighbors into the heap.​

3.​ Stop when you reach the destination.​

🔁 Example Intuition
In essence, this is like Dijkstra, where:

●​ Distance = elevation required​

●​ You want the path that minimizes the maximum elevation encountered​

🥇 Best Approach: Dijkstra’s Algorithm

💻 Complete Java Code (With Comments + Driver)
import java.util.*;

public class SwimInRisingWater_Dijkstra {

public int swimInWater(int[][] grid) {

int n = grid.length;
 boolean[][] visited = new boolean[n][n];

int[][] directions = {{1,0},{-1,0},{0,1},{0,-1}};

// Min-heap storing (time, x, y)

PriorityQueue<int[]> pq = new
PriorityQueue<>(Comparator.comparingInt(a -> a[0]));

pq.offer(new int[]{grid[0][0], 0, 0});

int time = 0;

while (!pq.isEmpty()) {

int[] curr = pq.poll();

int t = curr[0], x = curr[1], y = curr[2];

time = Math.max(time, t); // maximum elevation seen so far

if (x == n - 1 && y == n - 1) return time; // reached end

if (visited[x][y]) continue;

visited[x][y] = true;

// Explore 4 directions

for (int[] d : directions) {

int nx = x + d[0], ny = y + d[1];

if (nx >= 0 && nx < n && ny >= 0 && ny < n &&

!visited[nx][ny]) {

pq.offer(new int[]{grid[nx][ny], nx, ny});

 }

return -1; // shouldn't reach here

// ---------------- DRIVER ----------------

public static void main(String[] args) {

SwimInRisingWater_Dijkstra solver = new SwimInRisingWater_Dijkstra();

int[][] grid1 = {

{0,2},

{1,3}

};

int[][] grid2 = {

{0,1,2,3,4},

{24,23,22,21,5},

{12,13,14,15,16},

{11,17,18,19,20},

{10,9,8,7,6}

};

System.out.println("Example 1: " + solver.swimInWater(grid1)); // 3

System.out.println("Example 2: " + solver.swimInWater(grid2)); // 16

 }

🧪 Output
Example 1: 3

Example 2: 16

✅ Works perfectly.

🔍 Dry Run (Example 1)

Grid:

02

13

Ste PQ Contents (t,x,y) Current Max time Action

p

1 (0,0,0) pop (0,0,0) 0 add (1,1,0),

(2,0,1)

2 (1,1,0), (2,0,1) pop (1,1,0) 1 add (3,1,1)

3 (2,0,1), (3,1,1) pop (2,0,1) 2 no new cells

4 (3,1,1) pop (3,1,1) 3 reached end ✅

✅ Minimum time = 3
⏱️ Complexity
Metric Value Explanation

Time O(N² log N) Each cell inserted in PQ

once

Space O(N²) For visited + PQ storage

🥈 Alternate Approach — Binary Search + BFS

Another elegant method:

1.​ Binary search on possible t (time).​

2.​ For each t, run BFS to check if you can reach the end with elevations ≤ t.​

💻 Binary Search + BFS Code

import java.util.*;

public class SwimInRisingWater_BinarySearch {

public int swimInWater(int[][] grid) {

int n = grid.length;

int left = grid[0][0], right = n * n - 1, ans = right;

while (left <= right) {

 int mid = (left + right) / 2;

if (canReach(grid, mid)) {

ans = mid;

right = mid - 1;

} else {

left = mid + 1;

return ans;

private boolean canReach(int[][] grid, int time) {

int n = grid.length;

boolean[][] visited = new boolean[n][n];

int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};

if (grid[0][0] > time) return false;

Queue<int[]> q = new LinkedList<>();

q.offer(new int[]{0,0});

visited[0][0] = true;

while (!q.isEmpty()) {

int[] cur = q.poll();

 int x = cur[0], y = cur[1];

if (x == n-1 && y == n-1) return true;

for (int[] d : dirs) {

int nx = x + d[0], ny = y + d[1];

if (nx >= 0 && nx < n && ny >= 0 && ny < n &&

!visited[nx][ny] && grid[nx][ny] <= time) {

visited[nx][ny] = true;

q.offer(new int[]{nx, ny});

return false;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

SwimInRisingWater_BinarySearch solver = new

SwimInRisingWater_BinarySearch();

int[][] grid = {

{0,2},

{1,3}

};

System.out.println("Binary Search Result: " +

solver.swimInWater(grid)); // 3

}
}

🧩 Comparison Table
Approach Time Spac Remarks
e

Dijkstra (Best) O(N² log N) O(N²) Fastest in practice

Binary Search + BFS O(N² log N²) O(N²) Conceptually clean, slightly slower

✅ Key Takeaways
●​ The problem is a minimum-maximum path on a grid.​

●​ Dijkstra’s Algorithm fits perfectly (priority queue based).​

●​ Binary Search + BFS is a clever alternate solution.​

●​ Common in Google, Meta, and Amazon interviews.​

Perfect 👽 — now we’re diving into one of the most conceptually rich graph problems —​
a blend of topological sorting, string comparison, and graph reasoning.

🪐 Alien Dictionary (Leetcode #269)

🧩 Problem Statement
There is a new alien language that uses the same English lowercase letters, but the order
of the letters is unknown.

You are given a list of words words sorted lexicographically according to this alien language.

You need to derive the order of the letters and return it as a string.

If there is no valid order (i.e., if the input is inconsistent), return an empty string.

🧮 Example 1
Input:

words = ["wrt", "wrf", "er", "ett", "rftt"]

Output:

"wertf"

Explanation:​
From comparisons:

"wrt" → "wrf" ⇒ 't' < 'f'

"wrf" → "er" ⇒ 'w' < 'e'

"er" → "ett" ⇒ 'r' < 't'

"ett" → "rftt" ⇒ 'e' < 'r'

✅
Combine relations → w < e < r < t < f​
Lexicographically valid order: "wertf"

🧮 Example 2
Input:

words = ["z", "x"]

Output:

"zx"

🧮 Example 3
Input:

words = ["z", "x", "z"]

Output:

""

Explanation:​
No valid ordering (cycle detected: z → x → z)

💡 Intuition
The words are already sorted according to alien rules.​
We can compare adjacent words to infer the relative order between characters.

Example:​
["wrt", "wrf"] → the first differing character is 't' and 'f' → 't' < 'f'.

By doing this for all adjacent pairs, we get edges between characters forming a directed
graph.

👉 Then, the problem reduces to finding a topological ordering of that graph.

🧠 Approach — Topological Sort (Kahn’s Algorithm)

1.​ Build an adjacency list for all characters.​

2.​ Compare each adjacent pair of words:​

 ○​ Find the first differing character.​

○​ Add a directed edge (from → to).​

3.​ Compute in-degrees for all nodes.​

4.​ Use a queue for characters with in-degree 0.​

5.​ Perform Kahn’s BFS Topological Sort.​

6.​ If all characters are visited → valid order.​

Otherwise → cycle → invalid order.​

🥇 Best Approach: Kahn’s Algorithm (BFS Topological

Sort)

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

public class AlienDictionary_Kahn {

public String alienOrder(String[] words) {

Map<Character, Set<Character>> graph = new HashMap<>();

Map<Character, Integer> indegree = new HashMap<>();

// Step 1: Initialize graph nodes

for (String word : words) {

for (char c : word.toCharArray()) {

graph.putIfAbsent(c, new HashSet<>());

indegree.putIfAbsent(c, 0);
 }

// Step 2: Build graph (edges from adjacent words)

for (int i = 0; i < words.length - 1; i++) {

String w1 = words[i], w2 = words[i + 1];

int len = Math.min(w1.length(), w2.length());

// Invalid case: prefix issue (["abc", "ab"])

if (w1.length() > w2.length() && w1.startsWith(w2)) return "";

for (int j = 0; j < len; j++) {

char c1 = w1.charAt(j), c2 = w2.charAt(j);

if (c1 != c2) {

if (!graph.get(c1).contains(c2)) {

graph.get(c1).add(c2);

indegree.put(c2, indegree.get(c2) + 1);

break;

// Step 3: BFS (Kahn's algorithm)

Queue<Character> queue = new LinkedList<>();

for (char c : indegree.keySet()) {

 if (indegree.get(c) == 0)

queue.offer(c);

StringBuilder order = new StringBuilder();

while (!queue.isEmpty()) {

char c = queue.poll();

order.append(c);

for (char nei : graph.get(c)) {

indegree.put(nei, indegree.get(nei) - 1);

if (indegree.get(nei) == 0) queue.offer(nei);

// Step 4: Validate (check for cycle)

if (order.length() < indegree.size()) return "";

return order.toString();

// ---------------- DRIVER ----------------

public static void main(String[] args) {

AlienDictionary_Kahn solver = new AlienDictionary_Kahn();

 String[] words1 = {"wrt","wrf","er","ett","rftt"};

String[] words2 = {"z","x"};

String[] words3 = {"z","x","z"};

System.out.println("Example 1: " + solver.alienOrder(words1)); //

"wertf"

System.out.println("Example 2: " + solver.alienOrder(words2)); //

"zx"

System.out.println("Example 3: " + solver.alienOrder(words3)); // ""

🧪 Output
Example 1: wertf

Example 2: zx

Example 3:

✅ Works perfectly.

🔍 Step-by-Step Dry Run (Example 1)

Words:

["wrt","wrf","er","ett","rftt"]

Compare pairs:

wrt - wrf → t < f

wrf - er → w < e

er - ett → r < t

ett - rftt → e < r

Edges:

w→e

e→r

r→t

t→f

In-degree:

w:0, e:1, r:1, t:1, f:1

Topological Order:

Queue: [w]

→w→e→r→t→f

✅ Output: "wertf"

⏱️ Complexity
Metric Value Explanation

Time O(N × L) Compare adjacent words (N words of length L)

Space O(1–26) Max 26 characters (constant graph size)

🥈 Alternate Approach — DFS Topological Sort
Instead of BFS, we can use DFS postorder to build the order in reverse.

💻 DFS Code Version

import java.util.*;

public class AlienDictionary_DFS {

private Map<Character, Set<Character>> graph = new HashMap<>();

private Map<Character, Integer> state = new HashMap<>();

private StringBuilder order = new StringBuilder();

private boolean hasCycle = false;

public String alienOrder(String[] words) {

// Step 1: Initialize graph nodes

for (String word : words) {

for (char c : word.toCharArray()) {

graph.putIfAbsent(c, new HashSet<>());

state.putIfAbsent(c, 0);

// Step 2: Build graph edges

for (int i = 0; i < words.length - 1; i++) {

 String w1 = words[i], w2 = words[i + 1];

int len = Math.min(w1.length(), w2.length());

if (w1.length() > w2.length() && w1.startsWith(w2)) return "";

for (int j = 0; j < len; j++) {

char c1 = w1.charAt(j), c2 = w2.charAt(j);

if (c1 != c2) {

graph.get(c1).add(c2);

break;

// Step 3: DFS on each unvisited node

for (char c : graph.keySet()) {

if (state.get(c) == 0) dfs(c);

if (hasCycle) return "";

return order.reverse().toString();

private void dfs(char c) {

if (hasCycle) return;

state.put(c, 1); // visiting

 for (char nei : graph.get(c)) {

if (state.get(nei) == 1) { // cycle

hasCycle = true;

return;

if (state.get(nei) == 0)

dfs(nei);

state.put(c, 2); // done

order.append(c);

// ---------------- DRIVER ----------------

public static void main(String[] args) {

AlienDictionary_DFS solver = new AlienDictionary_DFS();

String[] words = {"wrt","wrf","er","ett","rftt"};

System.out.println("DFS Order: " + solver.alienOrder(words)); //

"wertf"

🧩 Comparison Table
Approach Time Space Remarks
 BFS (Kahn’s) O(N×L) O(1–26) Iterative, simple

DFS (Postorder) O(N×L) O(1–26) Recursive,

elegant

✅ Key Takeaways
●​ Build the graph by comparing adjacent words.​

●​ Use Topological Sort (BFS or DFS) to find the order.​

●​ Detect prefix conflicts and cycles.​

●​ Common in Google, Amazon, Meta, and Microsoft interviews.​

Awesome 😎 — let’s go into a beautiful shortest path + BFS problem that’s very popular
in interviews because it combines Dijkstra’s algorithm, graph traversal, and a constraint
on the number of stops.

🛫 Cheapest Flights Within K Stops

(Leetcode #787)

🧩 Problem Statement
You are given:

●​ n — number of cities (numbered 0 to n-1),​

●​ flights[i] = [from, to, price] — representing a flight,​

 ●​ Two cities: src (starting city) and dst (destination),​

●​ k — maximum number of stops allowed (not counting the destination).​

👉
Your task:​
Find the cheapest price to get from src to dst with at most k stops.​
If there is no such route, return -1.

🧮 Example 1
Input:

n=4

flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]]

src = 0, dst = 3, k = 1

Output:

700

Explanation:

0 -> 1 -> 3 = 100 + 600 = 700

Other paths:

0 -> 1 -> 2 -> 3 = 100 + 100 + 200 = 400 ❌ (too many stops)

💡 Intuition
We are looking for the minimum cost path but with a stop limit (k).

Classic Dijkstra finds the shortest path, but it doesn’t handle a limit on stops.​
We modify it by tracking both:
 ●​ current city​

●​ number of stops so far​

🧠 Approach 1 — BFS (Modified Dijkstra’s)

We use a priority queue (min-heap) that stores tuples:

[cost, city, stops]

Algorithm:

1.​ Build an adjacency list graph[from] → [(to, cost)].​

2.​ Use a min-heap starting from (0, src, 0).​

3.​ Pop the smallest cost element each time.​

4.​ If we reach dst, return its cost.​

5.​ Push neighboring cities only if stops <= k.​

🥇 Best Approach: Modified Dijkstra’s (Priority Queue)

💻 Complete Java Code (With Comments + Driver)
import java.util.*;

public class CheapestFlightsWithinKStops {

public int findCheapestPrice(int n, int[][] flights, int src, int dst,

int k) {

// Step 1: Build the adjacency list

 Map<Integer, List<int[]>> graph = new HashMap<>();

for (int[] flight : flights) {

graph.computeIfAbsent(flight[0], key -> new ArrayList<>())

.add(new int[]{flight[1], flight[2]}); // [to, price]

// Step 2: Min-heap => [cost, city, stops]

PriorityQueue<int[]> pq = new
PriorityQueue<>(Comparator.comparingInt(a -> a[0]));

pq.offer(new int[]{0, src, 0});

// Step 3: To store best known (city, stops)

int[][] best = new int[n][k + 2];

for (int[] row : best) Arrays.fill(row, Integer.MAX_VALUE);

best[src][0] = 0;

// Step 4: Process queue

while (!pq.isEmpty()) {

int[] curr = pq.poll();

int cost = curr[0], city = curr[1], stops = curr[2];

if (city == dst) return cost; // Found destination

if (stops > k) continue;

// Explore neighbors
 for (int[] nei : graph.getOrDefault(city, new ArrayList<>())) {

int nextCity = nei[0], price = nei[1];

int newCost = cost + price;

// Only push if this path is cheaper for given stops

if (newCost < best[nextCity][stops + 1]) {

best[nextCity][stops + 1] = newCost;

pq.offer(new int[]{newCost, nextCity, stops + 1});

return -1; // No path found

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CheapestFlightsWithinKStops solver = new

CheapestFlightsWithinKStops();

int n = 4;

int[][] flights = {

{0,1,100},

{1,2,100},

{2,0,100},

{1,3,600},
 {2,3,200}

};

int src = 0, dst = 3, k = 1;

int ans = solver.findCheapestPrice(n, flights, src, dst, k);

System.out.println("Cheapest price: " + ans); // Output: 700

🧪 Output
Cheapest price: 700

✅ Works perfectly.

🔍 Dry Run (Example)

Input:

n=4, flights=[[0,1,100],[1,3,600],[1,2,100],[2,3,200]]

src=0, dst=3, k=1

Graph:

0 → (1,100)

1 → (2,100), (3,600)

2 → (3,200)
PQ:

[0,0,0]

→ Pop (0,0,0): explore neighbors

push (100,1,1)

→ Pop (100,1,1): explore neighbors

push (700,3,2)

push (200,2,2)

→ Pop (700,3,2): destination reached ✅

Answer = 700

⏱️ Complexity
Metric Value Explanation

Time O(E × log(E)) Each edge may enter PQ

once

Space O(V + E) Graph + PQ + best[][]

🥈 Alternate Approach — BFS (Without Priority Queue)

Simpler but less efficient version (used when edge weights are small).

💻 BFS Approach Code

import java.util.*;
public class CheapestFlights_BFS {

public int findCheapestPrice(int n, int[][] flights, int src, int dst,

int k) {

Map<Integer, List<int[]>> graph = new HashMap<>();

for (int[] flight : flights) {

graph.computeIfAbsent(flight[0], key -> new ArrayList<>())

.add(new int[]{flight[1], flight[2]});

int[] dist = new int[n];

Arrays.fill(dist, Integer.MAX_VALUE);

dist[src] = 0;

Queue<int[]> q = new LinkedList<>();

q.offer(new int[]{src, 0});

int stops = 0;

while (!q.isEmpty() && stops <= k) {

int size = q.size();

int[] temp = Arrays.copyOf(dist, n);

for (int i = 0; i < size; i++) {

int[] curr = q.poll();

int city = curr[0], cost = curr[1];

 for (int[] nei : graph.getOrDefault(city, new ArrayList<>()))
{

int nextCity = nei[0], price = nei[1];

if (cost + price < temp[nextCity]) {

temp[nextCity] = cost + price;

q.offer(new int[]{nextCity, temp[nextCity]});

dist = temp;

stops++;

return dist[dst] == Integer.MAX_VALUE ? -1 : dist[dst];

public static void main(String[] args) {

CheapestFlights_BFS solver = new CheapestFlights_BFS();

int n = 4;

int[][] flights = {

{0,1,100},

{1,2,100},

{2,0,100},

{1,3,600},
 {2,3,200}

};

System.out.println("BFS Price: " + solver.findCheapestPrice(n,

flights, 0, 3, 1)); // 700

🧩 Comparison Table
Approach Time Space Remarks

Dijkstra + Stops O(E log E) O(V + E) Efficient for large graphs

(Best)

BFS (Layered) O(k·E) O(V + E) Easier, less optimal

✅ Key Takeaways
●​ This problem combines shortest path + limited edges.​

●​ Dijkstra’s with a (cost, node, stops) triple works best.​

●​ BFS is fine for small graphs or when edge weights are small.​

●​ Often asked by Google, Amazon, Microsoft, Uber.​

1D DP
Perfect 🪜 — let’s start the 1-D Dynamic Programming series strong!​
We’ll begin with the classic, foundational problem that introduces the essence of DP.

🧩 Climbing Stairs (Leetcode #70)

🧠 Problem Statement
You are climbing a staircase.​
It takes n steps to reach the top.

Each time you can either climb 1 step or 2 steps.​

How many distinct ways can you climb to the top?

🧮 Example 1
Input:

n=2

Output:

Explanation:

●​ (1 + 1)​

●​ (2)​

🧮 Example 2
Input:

n=3

Output:
3

Explanation:

●​ (1 + 1 + 1)​

●​ (1 + 2)​

●​ (2 + 1)​

💡 Intuition
To reach the n-th step:

●​ You must have come from (n−1) or (n−2) step.​

So,

ways(n) = ways(n−1) + ways(n−2)

This is literally the Fibonacci sequence pattern.

🧠 Approach 1 — Dynamic Programming (Bottom-Up)

We use a DP array dp[i] representing the number of ways to reach step i.

Recurrence:
dp[i] = dp[i-1] + dp[i-2]

Base Cases:
dp[1] = 1
dp[2] = 2

🥇 Best Approach — DP with O(1) Space Optimization

Instead of using an entire array,​
we can just store the previous two values.

💻 Complete Java Code (With Comments + Driver)

public class ClimbingStairs {

public int climbStairs(int n) {

if (n <= 2) return n; // base cases

int oneStepBefore = 2;
int twoStepsBefore = 1;
int allWays = 0;

// bottom-up calculation
for (int i = 3; i <= n; i++) {
allWays = oneStepBefore + twoStepsBefore;
twoStepsBefore = oneStepBefore;
oneStepBefore = allWays;
}

return allWays;
}

// ---------------- DRIVER ----------------

public static void main(String[] args) {
ClimbingStairs solver = new ClimbingStairs();

System.out.println("n = 2 → " + solver.climbStairs(2)); // 2

System.out.println("n = 3 → " + solver.climbStairs(3)); // 3
System.out.println("n = 5 → " + solver.climbStairs(5)); // 8
}
}

🧪 Output
n=2→2
n=3→3
n=5→8

✅ Works perfectly.
🔍 Dry Run (Example n = 5)
Ste oneStepBefor twoStepsBefor allWays
p e e

Init 2 1 —

i=3 2 1 3

i=4 3 2 5

i=5 5 3 8

✅ Total ways = 8

⏱️ Complexity
Metric Value Explanation

Time O(n) Single pass

Space O(1) Only two vars stored

🥈 Alternate Approach — Recursive + Memoization

Simple top-down recursive approach using a cache.

💻 Code
import java.util.*;

public class ClimbingStairs_Recursive {

private Map<Integer, Integer> memo = new HashMap<>();

public int climbStairs(int n) {

if (n <= 2) return n;
if (memo.containsKey(n)) return memo.get(n);

int ways = climbStairs(n - 1) + climbStairs(n - 2);

memo.put(n, ways);
return ways;
}
 public static void main(String[] args) {
ClimbingStairs_Recursive solver = new ClimbingStairs_Recursive();
System.out.println("n = 4 → " + solver.climbStairs(4)); // 5
}
}

🧩 Comparison Table
Approach Time Spac Remarks
e

DP (Iterative, O(1) Space) O(n) O(1) ✅ Best for interviews

Recursive + Memoization O(n) O(n) Simpler conceptually

Plain Recursion O(2ⁿ) O(n) ❌ Exponential, not efficient

✅ Key Takeaways
●​ A foundation problem for DP — same as Fibonacci.​

●​ Transition formula: f(n) = f(n−1) + f(n−2).​

●​ Always optimize to O(1) space for linear DP.​

●​ Asked in Amazon, Microsoft, Google, etc.​

Excellent ⚡ — let’s level up from Climbing Stairs to a slightly more realistic version —
where each step has a cost!

This one is a direct extension and helps you build intuition for Dynamic Programming with
cost optimization.
🧩 Min Cost Climbing Stairs (Leetcode
#746)

🧠 Problem Statement
You are given an integer array cost where cost[i] is the cost of stepping on the i-th
stair.

Once you pay the cost, you can climb either one or two steps.

You can start from step 0 or step 1,​

and your goal is to reach the top (beyond the last index) with the minimum total cost.

🧮 Example 1
Input:

cost = [10, 15, 20]

Output:

15

Explanation:

●​ Start at index 1 (cost 15)​

✅
●​ Jump two steps to the top​
Total = 15​

🧮 Example 2
Input:

cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]

Output:

Explanation:

Take steps: 0 → 2 → 3 → 4 → 6 → 7 → 9 → top

Total = 1 + 1 + 1 + 1 + 1 + 1 = 6

💡 Intuition
This is very similar to Climbing Stairs,​
but here we must pay cost[i] when we step on the stair.

We want to minimize the total cost to reach the top (beyond the last step).

🔢 Recurrence Relation
To reach step i, you could have come from:

●​ step i-1 (pay cost[i-1])​

●​ step i-2 (pay cost[i-2])​

So:

dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2])

And the final answer is dp[n]​

(where n = cost.length → represents "beyond last step").
🧠 Approach 1 — Dynamic Programming (Bottom-Up,
O(1) Space)
We just need the previous two states.

💻 Complete Java Code (With Comments + Driver)

public class MinCostClimbingStairs {

public int minCostClimbingStairs(int[] cost) {

int n = cost.length;

if (n == 1) return cost[0];

int prev2 = 0; // cost to reach step 0

int prev1 = 0; // cost to reach step 1

for (int i = 2; i <= n; i++) {

int curr = Math.min(prev1 + cost[i - 1], prev2 + cost[i - 2]);

prev2 = prev1;

prev1 = curr;

return prev1;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

 MinCostClimbingStairs solver = new MinCostClimbingStairs();

int[] cost1 = {10, 15, 20};

int[] cost2 = {1, 100, 1, 1, 1, 100, 1, 1, 100, 1};

System.out.println("Example 1: " +
solver.minCostClimbingStairs(cost1)); // 15

System.out.println("Example 2: " +
solver.minCostClimbingStairs(cost2)); // 6

🧪 Output
Example 1: 15

Example 2: 6

✅ Works perfectly.

🔍 Dry Run (Example 1: cost = [10, 15, 20])

i dp[i-2] + cost[i-2] dp[i-1] + cost[i-1] dp[i] Explanation

2 0 + 10 0 + 15 10 min(10,15)=10

3 0 + 15 10 + 20 15 min(15,30)=15

✅ Answer = dp[3] = 15
⏱️ Complexity
Metric Value Explanation

Time O(n) Single pass through array

Space O(1) Only two vars (prev1, prev2)

🥈 Alternate Approach — Recursive + Memoization

💻 Recursive Code (Top-Down)
import java.util.*;

public class MinCostClimbingStairs_Recursive {

private Map<Integer, Integer> memo = new HashMap<>();

public int minCostClimbingStairs(int[] cost) {

int n = cost.length;

return Math.min(helper(cost, n - 1), helper(cost, n - 2));

private int helper(int[] cost, int i) {

if (i < 0) return 0;

if (i == 0 || i == 1) return cost[i];
 if (memo.containsKey(i)) return memo.get(i);

int minCost = cost[i] + Math.min(helper(cost, i - 1), helper(cost, i

- 2));

memo.put(i, minCost);

return minCost;

public static void main(String[] args) {

MinCostClimbingStairs_Recursive solver = new

MinCostClimbingStairs_Recursive();

int[] cost = {10, 15, 20};

System.out.println("Recursive Result: " +

solver.minCostClimbingStairs(cost)); // 15

🧩 Comparison Table
Approach Time Spac Remarks
e

Iterative (Best) O(n) O(1) ✅ Optimal

Recursive + O(n) O(n) Simpler conceptually
Memo

Plain Recursion O(2ⁿ) O(n) ❌ Not efficient

✅ Key Takeaways
●​ This is the "Climbing Stairs" problem with weights/costs.​

Transition formula:​
​
dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2])

●​
●​ Optimize to O(1) space easily.​

●​ Interviewers use it to test DP optimization and understanding of state transitions.​

●​ Common at Amazon, Meta, Google, Microsoft.​

Perfect 🏠💰 — we’re now stepping into one of the most iconic dynamic programming
problems ever —​
the House Robber problem.

This problem introduces non-adjacent selection — a pattern that reappears in many DP

questions (like "Maximum Sum of Non-Adjacent Elements", "Delete and Earn", etc).

🧩 House Robber (Leetcode #198)

🧠 Problem Statement
You are a professional robber planning to rob houses along a street.​
Each house has a certain amount of money stashed, represented by an integer array nums.

👉
The only constraint is:​
You cannot rob two adjacent houses (security system will alert police).

Return the maximum amount of money you can rob without triggering the alarm.
🧮 Example 1
Input:

nums = [1,2,3,1]

Output:

Explanation:

Rob house 1 (money = 1)

Skip house 2

Rob house 3 (money = 3)

Total = 1 + 3 = 4

🧮 Example 2
Input:

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

Output:

12

Explanation:

Rob house 1 (2), skip 2, rob 3 (9), skip 4, rob 5 (1)

Total = 2 + 9 + 1 = 12
💡 Intuition
At every house i, you have two choices:

1.​ Rob it → you can’t rob the previous one → profit = nums[i] + dp[i-2]​

2.​ Skip it → profit = dp[i-1]​

So recurrence:

dp[i] = max(nums[i] + dp[i-2], dp[i-1])

🧠 Approach 1 — Dynamic Programming (Bottom-Up,

O(1) Space)
We only need two previous values (dp[i-1] and dp[i-2]).

💻 Complete Java Code (With Comments + Driver)

public class HouseRobber {

public int rob(int[] nums) {

int n = nums.length;

if (n == 0) return 0;

if (n == 1) return nums[0];

int prev2 = nums[0]; // max till house 0

int prev1 = Math.max(nums[0], nums[1]); // max till house 1

int curr = prev1;

 for (int i = 2; i < n; i++) {

curr = Math.max(nums[i] + prev2, prev1);

prev2 = prev1;

prev1 = curr;

return curr;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

HouseRobber solver = new HouseRobber();

int[] nums1 = {1,2,3,1};

int[] nums2 = {2,7,9,3,1};

System.out.println("Example 1: " + solver.rob(nums1)); // 4

System.out.println("Example 2: " + solver.rob(nums2)); // 12

🧪 Output
Example 1: 4

Example 2: 12
✅ Works perfectly.

🔍 Dry Run (Example: nums = [2,7,9,3,1])

i nums[i] prev2 prev1 curr Explanation

0 2 — — 2 Base case

1 7 — — 7 max(2,7)=7

2 9 2 7 11 max(9+2,7)=11

3 3 7 11 11 max(3+7,11)=11

4 1 11 11 12 max(1+11,11)=12

✅ Answer = 12

⏱️ Complexity
Metric Value Explanation

Time O(n) Single pass

Space O(1) Only two vars kept

🥈 Alternate Approach — Recursive + Memoization
💻 Code
import java.util.*;

public class HouseRobber_Recursive {

private Map<Integer, Integer> memo = new HashMap<>();

public int rob(int[] nums) {

return helper(nums, nums.length - 1);

private int helper(int[] nums, int i) {

if (i < 0) return 0;

if (i == 0) return nums[0];

if (memo.containsKey(i)) return memo.get(i);

int rob = nums[i] + helper(nums, i - 2);

int skip = helper(nums, i - 1);

int result = Math.max(rob, skip);

memo.put(i, result);

return result;

}
 public static void main(String[] args) {

HouseRobber_Recursive solver = new HouseRobber_Recursive();

int[] nums = {2,7,9,3,1};

System.out.println("Recursive result: " + solver.rob(nums)); // 12

🧩 Comparison Table
Approach Time Spac Remarks
e

DP (Iterative, O(1)) O(n) O(1) ✅ Best

Recursive + Memo O(n) O(n) Simple, but extra memory

Plain Recursion O(2ⁿ) O(n) ❌ Exponential

✅ Key Takeaways
●​ Transition: dp[i] = max(dp[i−1], dp[i−2] + nums[i])​

●​ Foundation for many advanced DP problems like:​

○​ House Robber II​

○​ Delete and Earn​

○​ Paint House​
 ●​ Optimize space down to O(1)​

●​ Asked by Amazon, Google, Microsoft, Facebook, Netflix​

🔥 Awesome — we’re now ready for the next-level version of House Robber — the
circular street version 💰🏠

This problem takes your 1-D DP understanding and tests how you adapt it when the
constraints slightly change.

🧩 House Robber II (Leetcode #213)

🧠 Problem Statement
You are still a professional robber, but this time the houses are arranged in a circle.

That means:

●​ The first and last houses are adjacent.​

●​ You cannot rob both the first and last houses.​

Return the maximum amount of money you can rob tonight without alerting the police.

🧮 Example 1
Input:

nums = [2,3,2]

Output:

3
Explanation:​
You can only rob one of house 1 or house 3 because they’re adjacent.​
Rob house 2 → Total = 3

🧮 Example 2
Input:

nums = [1,2,3,1]

Output:

Explanation:​
You can rob house 2 and 4 (2 + 2 = 4).

💡 Intuition
If houses were in a straight line, we’d use the House Robber I logic.

But now, because the first and last houses are connected,​
we can’t rob both together.

So we handle two cases:

1.​ Exclude the last house → Rob houses [0...n-2]​

2.​ Exclude the first house → Rob houses [1...n-1]​

Then take the maximum of both.

🔢 Formula
result = max(rob(nums[0...n-2]), rob(nums[1...n-1]))
🧠 Approach — DP with Helper Function
We can reuse the same logic from House Robber I to handle both subarrays.

💻 Complete Java Code (With Comments + Driver)

public class HouseRobberII {

public int rob(int[] nums) {

int n = nums.length;

if (n == 1) return nums[0]; // only one house

if (n == 2) return Math.max(nums[0], nums[1]); // two houses

// Case 1: exclude last house

int case1 = robLinear(nums, 0, n - 2);

// Case 2: exclude first house

int case2 = robLinear(nums, 1, n - 1);

return Math.max(case1, case2);

// Helper function: rob houses from start to end (inclusive)

private int robLinear(int[] nums, int start, int end) {

int prev2 = 0;

int prev1 = 0;
 for (int i = start; i <= end; i++) {

int curr = Math.max(prev1, prev2 + nums[i]);

prev2 = prev1;

prev1 = curr;

return prev1;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

HouseRobberII solver = new HouseRobberII();

int[] nums1 = {2,3,2};

int[] nums2 = {1,2,3,1};

int[] nums3 = {1,2,3};

System.out.println("Example 1: " + solver.rob(nums1)); // 3

System.out.println("Example 2: " + solver.rob(nums2)); // 4

System.out.println("Example 3: " + solver.rob(nums3)); // 3

🧪 Output
Example 1: 3

Example 2: 4
Example 3: 3

✅ Works for all cases.

🔍 Dry Run (nums = [1,2,3,1])

Case 1: Exclude last → [1,2,3]

dp = [1,2,4]

→ max = 4

Case 2: Exclude first → [2,3,1]

dp = [2,3,3]

→ max = 3

✅ Final result = max(4, 3) = 4

⏱️ Complexity
Metric Value Explanation

Time O(n) Two passes of linear

DP

Space O(1) Only a few variables

🥈 Alternate Approach — Recursive + Memoization

(Conceptually same, but less efficient due to recursion overhead)

💻 Code
import java.util.*;

public class HouseRobberII_Recursive {

private Map<String, Integer> memo = new HashMap<>();

public int rob(int[] nums) {

int n = nums.length;

if (n == 1) return nums[0];

if (n == 2) return Math.max(nums[0], nums[1]);

return Math.max(helper(nums, 0, n - 2), helper(nums, 1, n - 1));

private int helper(int[] nums, int start, int end) {

return robRange(nums, end, start);

private int robRange(int[] nums, int i, int start) {

if (i < start) return 0;

String key = i + "-" + start;

if (memo.containsKey(key)) return memo.get(key);

int rob = nums[i] + robRange(nums, i - 2, start);

 int skip = robRange(nums, i - 1, start);

int res = Math.max(rob, skip);

memo.put(key, res);

return res;

public static void main(String[] args) {

HouseRobberII_Recursive solver = new HouseRobberII_Recursive();

int[] nums = {1,2,3,1};

System.out.println("Recursive Result: " + solver.rob(nums)); // 4

🧩 Comparison Table
Approach Time Spac Remarks
e

DP (Iterative) O(n) O(1) ✅ Best

Recursive + O(n) O(n) Simpler conceptually
Memo

Plain Recursion O(2ⁿ) O(n) ❌ Not feasible

✅ Key Takeaways
●​ The circle constraint means first and last can’t both be robbed.​

●​ Split into two linear DP subproblems.​

●​ Reuse House Robber I logic.​

●​ Common trick for circular problems (e.g., “Circular Array Sum”, “Circular House
Painting”).​

●​ Frequently asked in Amazon, Apple, Meta, Google interviews.​

Perfect 🌸
— now we’re moving into one of the most elegant and fundamental string DP
problems —

🧩 Longest Palindromic Substring

(Leetcode #5)

🧠 Problem Statement
Given a string s, return the longest palindromic substring in s.

A palindrome is a string that reads the same forward and backward.

🧮 Example 1
Input:

s = "babad"

Output:

"bab"
Explanation:​
"aba" is also a valid answer.

🧮 Example 2
Input:

s = "cbbd"

Output:

"bb"

💡 Intuition
A palindrome mirrors around its center.​
So, for every index, the palindrome could be:

●​ Odd length (center = one character)​

●​ Even length (center = between two characters)​

We can expand around each center and track the longest palindrome.

This is an O(n²) but beautifully simple approach.

🧠 Approach 1 — Expand Around Center (Best

Practical Approach)
For each position in the string:

●​ Expand outward (left and right) while s[left] == s[right].​

●​ Track the start and max length.​

💻 Complete Java Code (With Comments + Driver)
public class LongestPalindromicSubstring {

private int start = 0, maxLen = 0;

public String longestPalindrome(String s) {

if (s == null || s.length() < 2) return s;

for (int i = 0; i < s.length(); i++) {

// Odd length palindrome (center at i)

expandFromCenter(s, i, i);

// Even length palindrome (center between i and i+1)

expandFromCenter(s, i, i + 1);

return s.substring(start, start + maxLen);

// Expand around center

private void expandFromCenter(String s, int left, int right) {

while (left >= 0 && right < s.length() && s.charAt(left) ==

s.charAt(right)) {

left--;

right++;
 }

// after breaking, (left+1, right-1) is the palindrome range

int len = right - left - 1;

if (len > maxLen) {

start = left + 1;

maxLen = len;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

LongestPalindromicSubstring solver = new

LongestPalindromicSubstring();

System.out.println("Example 1: " +
solver.longestPalindrome("babad")); // "bab" or "aba"

System.out.println("Example 2: " + solver.longestPalindrome("cbbd"));

// "bb"

System.out.println("Example 3: " + solver.longestPalindrome("a"));

// "a"

System.out.println("Example 4: " + solver.longestPalindrome("ac"));

// "a"

🧪 Output
Example 1: bab
Example 2: bb

Example 3: a

Example 4: a

✅ Works perfectly.

🔍 Dry Run (s = "babad")

Center Expansio Palindrome Found
n

i=0 ('b') "b" "b"

i=1 ('a') "bab" ✅ length=3

i=2 ('b') "aba" ✅ length=3
i=3 ('a') "a" "a"

i=4 ('d') "d" "d"

✅ Longest palindrome = "bab"

⏱️ Complexity
Metric Value Explanation
 Time O(n²) Expanding around each
center

Space O(1) Constant space used

🧠 Approach 2 — Dynamic Programming (DP Table)

We can also use a DP table where:

dp[i][j] = true if substring s[i..j] is palindrome

Recurrence:

dp[i][j] = (s[i] == s[j]) && (j - i < 3 || dp[i+1][j-1])

💻 Code for DP Table Approach

public class LongestPalindromicSubstringDP {

public String longestPalindrome(String s) {

int n = s.length();

if (n < 2) return s;

boolean[][] dp = new boolean[n][n];

int start = 0, maxLen = 1;

// All single chars are palindromes

for (int i = 0; i < n; i++)

 dp[i][i] = true;

for (int end = 1; end < n; end++) {

for (int startIdx = 0; startIdx < end; startIdx++) {

if (s.charAt(startIdx) == s.charAt(end)) {

if (end - startIdx < 3 || dp[startIdx + 1][end - 1]) {

dp[startIdx][end] = true;

if (end - startIdx + 1 > maxLen) {

maxLen = end - startIdx + 1;

start = startIdx;

return s.substring(start, start + maxLen);

// ---------------- DRIVER ----------------

public static void main(String[] args) {

LongestPalindromicSubstringDP solver = new

LongestPalindromicSubstringDP();

System.out.println("DP Approach: " +

solver.longestPalindrome("babad")); // "bab" or "aba"

}
🧩 Comparison Table
Approach Time Spac Remarks
e

Expand Around Center O(n²) O(1) ✅ Best practical approach

DP Table O(n²) O(n²) Educational, but memory-heavy

Manacher’s Algorithm O(n) O(n) ⚙️ Advanced, rarely required in interviews

✅ Key Takeaways
●​ A palindrome mirrors around its center.​

●​ Expanding from each center is efficient and elegant.​

●​ Master this to easily handle:​

○​ Longest Palindromic Subsequence​

○​ Palindromic Substrings Count​

○​ Minimum Deletions to Make Palindrome​

Awesome 💫 — we’re now continuing with another elegant string DP problem:​

the Palindromic Substrings problem — a sister of the previous one.

This one is conceptually simple once you understand the “expand around center”
technique from Longest Palindromic Substring.
🧩 Palindromic Substrings (Leetcode
#647)

🧠 Problem Statement
Given a string s, return the number of palindromic substrings in it.

A substring is palindromic if it reads the same backward as forward.

🧮 Example 1
Input:

s = "abc"

Output:

Explanation:​
Palindromic substrings are: "a", "b", "c"

🧮 Example 2
Input:

s = "aaa"

Output:

6
Explanation:​
Palindromic substrings are:​
"a", "a", "a", "aa", "aa", "aaa"

💡 Intuition
This is almost identical to Longest Palindromic Substring, except now:

●​ We don’t track the longest one — we count all palindromic substrings.​

For each index i,​

we expand around it (odd length) and between it and i+1 (even length)​
and count how many valid palindromes we find.

🧠 Approach 1 — Expand Around Center (Optimal &

Simple)
For each character (and each gap between characters):

1.​ Expand outward as long as s[left] == s[right]​

2.​ Count each valid palindrome​

💻 Complete Java Code (With Comments + Driver)

public class PalindromicSubstrings {

public int countSubstrings(String s) {

int n = s.length();

int count = 0;

for (int i = 0; i < n; i++) {

 // Odd-length palindromes

count += expandFromCenter(s, i, i);

// Even-length palindromes

count += expandFromCenter(s, i, i + 1);

return count;

// Expand around the given center

private int expandFromCenter(String s, int left, int right) {

int cnt = 0;

while (left >= 0 && right < s.length() && s.charAt(left) ==

s.charAt(right)) {

cnt++; // Found one palindrome

left--;

right++;

return cnt;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

PalindromicSubstrings solver = new PalindromicSubstrings();

 System.out.println("Example 1: " + solver.countSubstrings("abc")); //
3

System.out.println("Example 2: " + solver.countSubstrings("aaa")); //

6

System.out.println("Example 3: " + solver.countSubstrings("abba"));

// 6

🧪 Output
Example 1: 3

Example 2: 6

Example 3: 6

✅ Works perfectly.

🔍 Dry Run (s = "aaa")

Center Expansion Palindromes
Found

i=0 "a" 1

i=0,1 "aa" 1

i=1 "a" → "aaa" 2

 i=1,2 "aa" 1

i=2 "a" 1

✅ Total = 6

⏱️ Complexity
Metric Value Explanation

Time O(n²) Expanding around 2n−1

centers

Space O(1) Only counters used

🧠 Approach 2 — Dynamic Programming (DP Table)

We can also build a DP table where:

dp[i][j] = true if substring s[i..j] is palindrome

Then count all true entries.

💻 Code for DP Table Approach

public class PalindromicSubstringsDP {

public int countSubstrings(String s) {

int n = s.length();
 boolean[][] dp = new boolean[n][n];

int count = 0;

for (int end = 0; end < n; end++) {

for (int start = 0; start <= end; start++) {

if (s.charAt(start) == s.charAt(end)) {

if (end - start < 2 || dp[start + 1][end - 1]) {

dp[start][end] = true;

count++;

return count;

public static void main(String[] args) {

PalindromicSubstringsDP solver = new PalindromicSubstringsDP();

System.out.println("DP Approach: " + solver.countSubstrings("aaa"));

// 6

🧩 Comparison Table
 Approach Time Spac Remarks
e

Expand Around Center O(n²) O(1) ✅ Most efficient in practice

DP Table O(n²) O(n²) Educational, good for learning DP
basics

✅ Key Takeaways
●​ Expanding around centers is the most elegant and memory-efficient approach.​

●​ Foundation for problems like:​

○​ Longest Palindromic Substring​

○​ Count Palindromic Subsequences​

○​ Minimum Insertions to Form a Palindrome​

●​ Great to demonstrate clean, optimized O(1) space DP thinking.​

Awesome 🚀 — now we’ll move to a very popular and tricky dynamic programming
problem on strings —​
it’s all about decoding messages like "12" → "AB".

This one is extremely common in interviews at Amazon, Google, and Meta, because it
looks simple but requires careful recurrence reasoning.

🧩 Decode Ways (Leetcode #91)

🧠 Problem Statement
You are given a string s containing only digits, representing an encoded message.

We need to return the total number of ways to decode it —​

where:

●​ 'A' → 1​

●​ 'B' → 2​

●​ ...​

●​ 'Z' → 26​

🧮 Example 1
Input:

s = "12"

Output:

Explanation:​
"12" can be decoded as:

●​ "AB" → (1 2)​

●​ "L" → (12)​

🧮 Example 2
Input:

s = "226"
Output:

Explanation:​
"226" can be decoded as:

●​ "BZ" (2 26)​

●​ "VF" (22 6)​

●​ "BBF" (2 2 6)​

🧮 Example 3
Input:

s = "06"

Output:

Explanation:​
No valid decoding starts with '0'.

💡 Intuition
At every position i, we can decode:

1.​ One digit (s[i] → if it's between '1' and '9')​

2.​ Two digits (s[i-1]s[i] → if it's between "10" and "26")​

So, this is just like Climbing Stairs,​
but with conditions on when you can take 1 or 2 steps.

🔢 Recurrence
Let dp[i] = number of ways to decode up to index i-1 (i.e., first i chars).

Then:

dp[i] = 0

if s[i-1] != '0' → dp[i] += dp[i-1]

if s[i-2..i-1] is between "10" and "26" → dp[i] += dp[i-2]

🧠 Approach — Bottom-Up Dynamic Programming

(O(n) Time, O(1) Space)
We’ll use two variables to track previous results, just like Fibonacci.

💻 Complete Java Code (With Comments + Driver)

public class DecodeWays {

public int numDecodings(String s) {

if (s == null || s.length() == 0) return 0;

if (s.charAt(0) == '0') return 0;

int n = s.length();

int prev2 = 1; // dp[i-2]

int prev1 = 1; // dp[i-1]

 for (int i = 1; i < n; i++) {

int curr = 0;

// Single digit decode possible?

if (s.charAt(i) != '0') {

curr += prev1;

// Two digit decode possible?

int twoDigit = Integer.parseInt(s.substring(i - 1, i + 1));

if (twoDigit >= 10 && twoDigit <= 26) {

curr += prev2;

// Update for next iteration

prev2 = prev1;

prev1 = curr;

return prev1;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

DecodeWays solver = new DecodeWays();

 System.out.println("Example 1: " + solver.numDecodings("12")); // 2

System.out.println("Example 2: " + solver.numDecodings("226")); // 3

System.out.println("Example 3: " + solver.numDecodings("06")); // 0

System.out.println("Example 4: " + solver.numDecodings("2101")); // 1

🧪 Output
Example 1: 2

Example 2: 3

Example 3: 0

Example 4: 1

✅ Works perfectly.

🔍 Dry Run (s = "226")

i s[i-1:i+1] Single Decode Double Decode dp[i]

0 "2" ✅ ❌ dp[1]=1

1 "22" ✅ (from dp[1]) ✅ (from dp[0]) dp[2]=2

2 "26" ✅ (from dp[2]) ✅ (from dp[1]) dp[3]=3

✅ Result = 3
⏱️ Complexity
Metric Value Explanation

Time O(n) One pass through

string

Space O(1) Only 2 vars used

🥈 Alternate Approach — Recursive + Memoization

We can also solve this top-down by trying to decode 1 or 2 digits at each step.

💻 Recursive Code
import java.util.*;

public class DecodeWays_Recursive {

private Map<Integer, Integer> memo = new HashMap<>();

public int numDecodings(String s) {

if (s == null || s.length() == 0) return 0;

return helper(s, 0);

private int helper(String s, int index) {

 if (index == s.length()) return 1;

if (s.charAt(index) == '0') return 0;

if (memo.containsKey(index)) return memo.get(index);

// One digit

int ways = helper(s, index + 1);

// Two digits

if (index + 1 < s.length()) {

int num = Integer.parseInt(s.substring(index, index + 2));

if (num >= 10 && num <= 26) {

ways += helper(s, index + 2);

memo.put(index, ways);

return ways;

public static void main(String[] args) {

DecodeWays_Recursive solver = new DecodeWays_Recursive();

System.out.println("Recursive Result: " +

solver.numDecodings("226")); // 3

}
🧩 Comparison Table
Approach Time Spac Remarks
e

Iterative (Best) O(n) O(1) ✅ Fastest

Recursive + O(n) O(n) Easy to understand
Memo

Plain Recursion O(2ⁿ) O(n) ❌ Exponential time

✅ Key Takeaways
●​ Think of this as Climbing Stairs + Constraints.​

●​ Carefully handle '0' — it can’t stand alone.​

●​ Mastering this builds foundation for:​

○​ Decode Ways II​

○​ Binary String Decoding​

○​ Phone Number Combinations​

Perfect💰 — now we move to one of the most classic and interview-heavy DP problems
ever —​
a must-know for FAANG interviews:

🧩 Coin Change (Leetcode #322)

🧠 Problem Statement
You are given an integer array coins representing coin denominations and an integer
amount representing a total amount of money.

Return the fewest number of coins needed to make up that amount.​

If that amount cannot be made up, return -1.

🧮 Example 1
Input:

coins = [1,2,5], amount = 11

Output:

Explanation:​
11 = 5 + 5 + 1 → 3 coins.

🧮 Example 2
Input:

coins = [2], amount = 3

Output:

-1

🧮 Example 3
Input:

coins = [1], amount = 0

Output:

💡 Intuition
We want the minimum coins that sum up to a given amount.​
This is a variation of the Unbounded Knapsack problem —​
we can use each coin as many times as we want.

We can solve it using Dynamic Programming (Bottom-Up).

⚙️ Recurrence
Let dp[i] = minimum coins to form amount i.

Then:

dp[0] = 0 // Base: zero coins to make amount 0

dp[i] = min(dp[i], dp[i - coin] + 1) for each coin <= i

🧠 Approach — Bottom-Up DP (Best Approach)

We iteratively compute answers from 0 → amount.

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

public class CoinChange {

public int coinChange(int[] coins, int amount) {

// Initialize DP array

int max = amount + 1; // larger than any possible answer

int[] dp = new int[amount + 1];

Arrays.fill(dp, max);

dp[0] = 0; // base case

// Build up solutions

for (int i = 1; i <= amount; i++) {

for (int coin : coins) {

if (coin <= i) {

dp[i] = Math.min(dp[i], dp[i - coin] + 1);

// If dp[amount] wasn't updated, no solution exists

return dp[amount] > amount ? -1 : dp[amount];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

CoinChange solver = new CoinChange();

 System.out.println("Example 1: " + solver.coinChange(new
int[]{1,2,5}, 11)); // 3

System.out.println("Example 2: " + solver.coinChange(new int[]{2},

3)); // -1

System.out.println("Example 3: " + solver.coinChange(new int[]{1},

0)); // 0

System.out.println("Example 4: " + solver.coinChange(new

int[]{1,3,4,5}, 7)); // 2 (3+4)

🧪 Output
Example 1: 3

Example 2: -1

Example 3: 0

Example 4: 2

✅ Works perfectly.

🔍 Dry Run (coins = [1, 2, 5], amount = 11)

i (Amount) dp[i] Computation Result

0 base 0

1 min(dp[1-1]+1) = 1 1
 2 min(dp[2-1]+1, dp[2-2]+1) = 1 1

3 min(dp[3-1]+1, dp[3-2]+1) = 2 2

4 min(dp[4-1]+1, dp[4-2]+1) = 2 2

5 min(dp[5-1]+1, dp[5-2]+1, dp[5-5]+1) = 1 1

6–11 ... → final = 3

✅ dp[11] = 3 → (5+5+1)

⏱️ Complexity
Metric Value Explanation

Time O(n × amount) For each coin, loop over

amount

Space O(amount) DP array only

🧩 Alternative Approach — Recursive + Memoization

We can also do this recursively by trying all coins and memoizing results.

💻 Recursive Code
import java.util.*;
public class CoinChangeRecursive {

private Map<Integer, Integer> memo = new HashMap<>();

public int coinChange(int[] coins, int amount) {

if (amount == 0) return 0;

if (amount < 0) return -1;

if (memo.containsKey(amount)) return memo.get(amount);

int min = Integer.MAX_VALUE;

for (int coin : coins) {

int res = coinChange(coins, amount - coin);

if (res >= 0 && res < min) {

min = res + 1;

memo.put(amount, (min == Integer.MAX_VALUE) ? -1 : min);

return memo.get(amount);

public static void main(String[] args) {

CoinChangeRecursive solver = new CoinChangeRecursive();

System.out.println("Recursive Result: " + solver.coinChange(new

int[]{1,2,5}, 11)); // 3

}
}

🧩 Comparison Table
Approach Time Space Remarks

Bottom-Up DP O(n × amount) O(amount) ✅ Best & cleanest

Top-Down Memo O(n × amount) O(amount) Easier to reason
recursively

Plain Recursion Exponential O(amount) ❌ Not feasible

✅ Key Takeaways
●​ Classic DP on combinations → “minimum number of ways to reach target”.​

●​ Think of it as unbounded knapsack with minimum count instead of maximum

value.​

●​ Foundation for:​

○​ Coin Change II (Count ways)​

○​ Minimum Number of Perfect Squares​

○​ Word Break (same DP structure)​

Perfect🔥 — this next one is a dynamic programming classic that tests your ability to
track both max and min values at each step — a must-know for technical interviews.
🧩 Maximum Product Subarray
(Leetcode #152)

🧠 Problem Statement
Given an integer array nums, find the subarray (contiguous elements) within the array that
has the largest product and return that product.

🧮 Example 1
Input:

nums = [2,3,-2,4]

Output:

Explanation:​
The subarray [2,3] has the largest product = 6.

🧮 Example 2
Input:

nums = [-2,0,-1]

Output:

Explanation:​
The subarray [0] has the largest product.
💡 Intuition
Unlike “Maximum Subarray Sum” (Kadane’s algorithm),​
here the product can flip sign when a negative number is involved.

👉 So we must track both the maximum and minimum product at each step, because:
●​ A large negative × negative = positive (can become new max)​

●​ A large positive × negative = negative (becomes new min)​

⚙️ Recurrence
Let:

●​ maxProd[i] = maximum product ending at index i​

●​ minProd[i] = minimum product ending at index i​

Then:

maxProd[i] = max(nums[i], nums[i]*maxProd[i-1], nums[i]*minProd[i-1])

minProd[i] = min(nums[i], nums[i]*maxProd[i-1], nums[i]*minProd[i-1])

🧠 Approach — Dynamic Programming (O(n) Time, O(1)

Space)
We just need two running variables for maxSoFar and minSoFar.

💻 Complete Java Code (With Comments + Driver)

public class MaximumProductSubarray {
public int maxProduct(int[] nums) {

if (nums == null || nums.length == 0) return 0;

int maxSoFar = nums[0]; // global max

int minEndingHere = nums[0];

int maxEndingHere = nums[0];

for (int i = 1; i < nums.length; i++) {

int curr = nums[i];

// If negative, swap because multiplying by negative flips signs

if (curr < 0) {

int temp = maxEndingHere;

maxEndingHere = minEndingHere;

minEndingHere = temp;

// Compute current max and min

maxEndingHere = Math.max(curr, curr * maxEndingHere);

minEndingHere = Math.min(curr, curr * minEndingHere);

// Update global max

maxSoFar = Math.max(maxSoFar, maxEndingHere);

}
 return maxSoFar;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

MaximumProductSubarray solver = new MaximumProductSubarray();

System.out.println("Example 1: " + solver.maxProduct(new

int[]{2,3,-2,4})); // 6

System.out.println("Example 2: " + solver.maxProduct(new

int[]{-2,0,-1})); // 0

System.out.println("Example 3: " + solver.maxProduct(new

int[]{-2,3,-4})); // 24

System.out.println("Example 4: " + solver.maxProduct(new

int[]{0,2})); // 2

🧪 Output
Example 1: 6

Example 2: 0

Example 3: 24

Example 4: 2

✅ Works for all edge cases — including negatives and zeros.

🔍 Dry Run (nums = [2,3,-2,4])

 i curr maxEndingHere minEndingHere maxSoFar

0 2 2 2 2

1 3 max(3, 2*3)=6 min(3, 2*3)=3 6

2 -2 swap (→ min=6, max=3) → max=-2 min=-12 6

3 4 max(4, -2*4)=4 min(4, -12*4)=-48 6

✅ Answer = 6

⏱️ Complexity
Metric Value Explanation

Time O(n) One pass through array

Space O(1) Only constant extra

variables

🧩 Alternate Approach — Brute Force (For

Understanding)
Try all subarrays and calculate product.​
Very inefficient but useful to understand the idea.

💻 Code (Brute Force)

public class MaximumProductSubarrayBruteForce {

public int maxProduct(int[] nums) {

int maxProduct = Integer.MIN_VALUE;

for (int i = 0; i < nums.length; i++) {

int prod = 1;

for (int j = i; j < nums.length; j++) {

prod *= nums[j];

maxProduct = Math.max(maxProduct, prod);

return maxProduct;

public static void main(String[] args) {

MaximumProductSubarrayBruteForce solver = new

MaximumProductSubarrayBruteForce();

System.out.println("Brute Force Result: " + solver.maxProduct(new

int[]{2,3,-2,4})); // 6

🧩 Comparison Table
 Approach Time Spac Remarks
e

DP (Best) O(n) O(1) ✅ Optimal

Brute Force O(n²) O(1) ❌ For understanding only

✅ Key Takeaways
●​ Track both max and min products because negatives flip signs.​

●​ Swap when encountering a negative number.​

●​ Similar to Kadane’s Algorithm, but with two state variables.​

Awesome 💪 — let’s now dive into Word Break (Leetcode #139) —​

a must-master dynamic programming problem that tests your ability to combine DP +
HashSet lookups to solve substring segmentation efficiently.

🧩 Word Break (Leetcode #139)

🧠 Problem Statement
Given a string s and a dictionary of strings wordDict, return true if s can be segmented
into one or more dictionary words.

Formally, return true if s can be written as:

s = w1 + w2 + ... + wk
where each wi is in wordDict.

🧮 Example 1
Input:

s = "leetcode"

wordDict = ["leet","code"]

Output:

true

Explanation:​
"leetcode" can be segmented as "leet code".

🧮 Example 2
Input:

s = "applepenapple"

wordDict = ["apple","pen"]

Output:

true

Explanation:​
"applepenapple" → "apple pen apple"

🧮 Example 3
Input:

s = "catsandog"
wordDict = ["cats","dog","sand","and","cat"]

Output:

false

💡 Intuition
We want to check if there exists a valid breakpoint in the string​
such that both halves are valid dictionary words (recursively).

This is a perfect case for Dynamic Programming, where:

●​ dp[i] = whether substring s[0...i-1] can be segmented into valid words.​

⚙️ Recurrence
For each index i (1 → n):

Check all prefixes ending at i:​

​
dp[i] = true if there exists a j < i such that:

dp[j] == true AND s.substring(j, i) ∈ wordDict

●​

🧠 Approach — Dynamic Programming (Bottom-Up)

We use an array dp of size n + 1, where:

●​ dp[0] = true (empty string can always be segmented)​

●​ dp[i] = true means substring s[0...i-1] can be segmented.​

💻 Complete Java Code (With Comments + Driver)
import java.util.*;

public class WordBreak {

public boolean wordBreak(String s, List<String> wordDict) {

Set<String> wordSet = new HashSet<>(wordDict);

int n = s.length();

boolean[] dp = new boolean[n + 1];

dp[0] = true; // base case: empty string

// Check all substrings

for (int i = 1; i <= n; i++) {

for (int j = 0; j < i; j++) {

// If prefix till j is valid AND substring j..i is a word

if (dp[j] && wordSet.contains(s.substring(j, i))) {

dp[i] = true;

break;

return dp[n];

}
 // ---------------- DRIVER ----------------

public static void main(String[] args) {

WordBreak solver = new WordBreak();

System.out.println("Example 1: " + solver.wordBreak("leetcode",

Arrays.asList("leet","code"))); // true

System.out.println("Example 2: " + solver.wordBreak("applepenapple",

Arrays.asList("apple","pen"))); // true

System.out.println("Example 3: " + solver.wordBreak("catsandog",

Arrays.asList("cats","dog","sand","and","cat"))); // false

🧪 Output
Example 1: true

Example 2: true

Example 3: false

✅ Works perfectly.

🔍 Dry Run (s = "leetcode", wordDict = ["leet", "code"])

i j s[j:i] dp[j] Word in Dict? dp[i]

0 - "" true — dp[0]=true

 1-3 — — — — dp[1-3]=false

4 0 "leet" true ✅ dp[4]=true

8 4 "code" true ✅ dp[8]=true

✅ dp[8] = true → segmentation possible.

⏱️ Complexity
Metric Value Explanation

Time O(n²) Double loop over string (i, j)

Space O(n) DP array

🧩 Alternate Approach — BFS (Graph-Based Thinking)

We can think of this as a graph traversal problem:​
Each index is a node, and an edge exists from i → j if s[i:j] ∈ wordDict.

👉
Then the question becomes:​
Can we reach index n starting from 0?

💻 BFS Code
import java.util.*;

public class WordBreakBFS {

public boolean wordBreak(String s, List<String> wordDict) {

Set<String> wordSet = new HashSet<>(wordDict);

Queue<Integer> queue = new LinkedList<>();

boolean[] visited = new boolean[s.length()];

queue.add(0);

while (!queue.isEmpty()) {

int start = queue.poll();

if (visited[start]) continue;

for (int end = start + 1; end <= s.length(); end++) {

if (wordSet.contains(s.substring(start, end))) {

if (end == s.length()) return true;

queue.add(end);

visited[start] = true;

return false;

public static void main(String[] args) {

WordBreakBFS solver = new WordBreakBFS();

 System.out.println("BFS Result: " + solver.wordBreak("applepenapple",
Arrays.asList("apple","pen"))); // true

🧩 Comparison Table
Approach Time Spac Remarks
e

DP (Best) O(n²) O(n) ✅ Deterministic & clean

BFS O(n²) O(n) Alternative using queue

DFS + Memo O(n²) O(n) Similar logic recursively

✅ Key Takeaways
●​ Classic substring + DP problem.​

●​ dp[i] represents “can break up to i”.​

●​ Avoid TLE by using a HashSet for word lookups.​

●​ Related problems:​

○​ Word Break II (return all possible sentences)​

○​ Concatenated Words​
 ○​ Minimum Word Breaks​

Awesome ⚡ — now we’ll cover one of the most fundamental and versatile DP problems
that shows up in almost every major interview prep roadmap:

🧩 Longest Increasing Subsequence

(LIS) — Leetcode #300

🧠 Problem Statement
Given an integer array nums, return the length of the longest strictly increasing
subsequence.

A subsequence is a sequence derived from the array by deleting some or no elements​

without changing the order of the remaining elements.

🧮 Example 1
Input:

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

Output:

Explanation:​
The longest increasing subsequence is [2,3,7,101].

🧮 Example 2
Input:

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

Output:

🧮 Example 3
Input:

nums = [7,7,7,7,7,7,7]

Output:

💡 Intuition
We want the maximum length of increasing subsequence,​
not necessarily contiguous — so we can’t use Kadane-style DP.

We have two great ways to solve this:

1.​ DP (O(n²)) — simpler and very intuitive.​

2.​ Binary Search (O(n log n)) — optimal and elegant.​

We’ll do both 💪.

⚙️ Approach 1 — Dynamic Programming (O(n²))

For each index i,
 ●​ look at all previous indices j < i,​

●​ and if nums[j] < nums[i],​

then we can extend the subsequence ending at j.​

Recurrence:

dp[i] = 1 + max(dp[j]) for all j < i where nums[j] < nums[i]

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

public class LongestIncreasingSubsequenceDP {

public int lengthOfLIS(int[] nums) {

int n = nums.length;

int[] dp = new int[n];

Arrays.fill(dp, 1); // each element is an LIS of length 1

int maxLen = 1;

for (int i = 1; i < n; i++) {

for (int j = 0; j < i; j++) {

if (nums[j] < nums[i]) {

dp[i] = Math.max(dp[i], dp[j] + 1);

}
 maxLen = Math.max(maxLen, dp[i]);

return maxLen;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

LongestIncreasingSubsequenceDP solver = new

LongestIncreasingSubsequenceDP();

System.out.println("Example 1: " + solver.lengthOfLIS(new

int[]{10,9,2,5,3,7,101,18})); // 4

System.out.println("Example 2: " + solver.lengthOfLIS(new

int[]{0,1,0,3,2,3})); // 4

System.out.println("Example 3: " + solver.lengthOfLIS(new

int[]{7,7,7,7,7})); // 1

🧪 Output
Example 1: 4

Example 2: 4

Example 3: 1

✅ Works perfectly.
🔍 Dry Run (nums = [10,9,2,5,3,7,101,18])
i nums[i] dp[i] Explanation

0 10 1 base

1 9 1 no smaller before

2 2 1 no smaller before

3 5 2 from 2 → 5

4 3 2 from 2 → 3

5 7 3 from 2,3,5 → 7

6 101 4 from 2,3,7 → 101

7 18 4 from 2,3,7 → 18

✅ LIS length = 4

⏱️ Complexity
Metric Value Explanation

Time O(n²) Two nested

loops
 Space O(n) DP array

🧠 Approach 2 — Binary Search (O(n log n)) (Optimal)

Instead of storing actual LIS, we maintain an array tails[]:

●​ tails[i] = smallest ending number of an increasing subsequence of length i+1.​

For each num in nums:

1.​ Use binary search to find the position where num fits in tails.​

2.​ Replace or append accordingly.​

At the end, the length of tails = length of LIS.

💻 Optimized Java Code (Binary Search Approach)

import java.util.*;

public class LongestIncreasingSubsequenceBinarySearch {

public int lengthOfLIS(int[] nums) {

int[] tails = new int[nums.length];

int size = 0;

for (int num : nums) {

int left = 0, right = size;

// Binary search to find position for current num

 while (left < right) {

int mid = left + (right - left) / 2;

if (tails[mid] < num) left = mid + 1;

else right = mid;

tails[left] = num;

if (left == size) size++; // extend LIS length

return size;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

LongestIncreasingSubsequenceBinarySearch solver = new

LongestIncreasingSubsequenceBinarySearch();

System.out.println("Example 1: " + solver.lengthOfLIS(new

int[]{10,9,2,5,3,7,101,18})); // 4

System.out.println("Example 2: " + solver.lengthOfLIS(new

int[]{0,1,0,3,2,3})); // 4

System.out.println("Example 3: " + solver.lengthOfLIS(new

int[]{7,7,7,7,7})); // 1

🧪 Dry Run (nums = [10,9,2,5,3,7,101,18])

 num tails (after siz
processing) e

10 [10] 1

9 [9] 1

2 [2] 1

5 [2,5] 2

3 [2,3] 2

7 [2,3,7] 3

101 [2,3,7,101] 4

18 [2,3,7,18] 4

✅ LIS length = 4

⏱️ Complexity (Binary Search)

Metric Value Explanation

Time O(n log n) Each number uses binary

search
Space O(n) Tails array

🧩 Comparison Table
Approach Time Spac Remarks
e

DP (O(n²)) O(n²) O(n) ✅ Easy to implement

Binary Search (O(n log n)) O(n log n) O(n) 🚀 Best performance for large n

✅ Key Takeaways
●​ LIS is a classic foundation problem — key for:​

○​ Russian Doll Envelopes​

○​ Longest Chain of Pairs​

○​ Building Bridges Problem​

●​ The binary search approach is elegant — store minimal possible tails.​

●​ LIS ≠ contiguous subarray — it’s subsequence-based.​

Perfect 🔥 — now we move to a core 0/1 Knapsack-style DP problem that shows up in

almost every interview prep list:
🧩 Partition Equal Subset Sum —
Leetcode #416

🧠 Problem Statement
Given an integer array nums, return true if you can partition the array into two subsets
such that the sum of elements in both subsets is equal.

Otherwise, return false.

🧮 Example 1
Input:

nums = [1,5,11,5]

Output:

true

Explanation:​
The array can be partitioned as [1, 5, 5] and [11].

🧮 Example 2
Input:

nums = [1,2,3,5]

Output:

false
Explanation:​
No equal partition exists.

💡 Intuition
Let the total sum of the array = S.​
To split into two equal subsets, both must sum to S/2.

👉
So the problem reduces to:​
Can we find a subset whose sum equals S/2?

If yes → return true.

⚙️ Step-by-Step Thought Process

1.​ If total sum is odd → can’t be split evenly → return false.​

2.​ Target = sum / 2​

3.​ Use DP (subset-sum pattern):​

○​ dp[i][t] = whether we can form sum t using first i elements.​

Recurrence:

dp[i][t] = dp[i-1][t] || dp[i-1][t - nums[i-1]]

(if nums[i-1] <= t)

💻 Approach 1 — DP (2D Boolean Table)

import java.util.*;

public class PartitionEqualSubsetSumDP {

public boolean canPartition(int[] nums) {

int sum = 0;

for (int num : nums) sum += num;

if (sum % 2 != 0) return false; // odd sum cannot be partitioned

int target = sum / 2;

int n = nums.length;

boolean[][] dp = new boolean[n + 1][target + 1];

// Base case: sum = 0 is always possible (by choosing no elements)

for (int i = 0; i <= n; i++) dp[i][0] = true;

for (int i = 1; i <= n; i++) {

for (int t = 1; t <= target; t++) {

if (nums[i - 1] <= t) {

dp[i][t] = dp[i - 1][t] || dp[i - 1][t - nums[i - 1]];

} else {

dp[i][t] = dp[i - 1][t];

return dp[n][target];

}
 // ---------------- DRIVER ----------------

public static void main(String[] args) {

PartitionEqualSubsetSumDP solver = new PartitionEqualSubsetSumDP();

System.out.println("Example 1: " + solver.canPartition(new

int[]{1,5,11,5})); // true

System.out.println("Example 2: " + solver.canPartition(new

int[]{1,2,3,5})); // false

🧪 Output
Example 1: true

Example 2: false

✅ Works correctly.

🔍 Dry Run (nums = [1,5,11,5])

●​ sum = 22, target = 11​

●​ Check if we can make 11 using subset of elements.​

i nums[i-1] Subset possible for target

11?

1 1 No
 2 5 No

3 11 ✅ Yes (using [11])

4 5 Still true

✅ Output → true

⏱️ Complexity
Metric Value Explanation

Time O(n * target) DP table of size n ×

target

Space O(n * target) 2D boolean DP table

⚙️ Approach 2 — Optimized 1D DP (Space Efficient)

We can use 1D DP since each row only depends on the previous row.

Idea:

●​ Use dp[t] to represent if sum t can be formed.​

●​ Iterate backward (to prevent reusing the same element twice).​

💻 Space-Optimized Java Code

import java.util.*;
public class PartitionEqualSubsetSumOptimized {

public boolean canPartition(int[] nums) {

int sum = 0;

for (int num : nums) sum += num;

if (sum % 2 != 0) return false;

int target = sum / 2;

boolean[] dp = new boolean[target + 1];

dp[0] = true; // base case

for (int num : nums) {

for (int t = target; t >= num; t--) {

dp[t] = dp[t] || dp[t - num];

return dp[target];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

PartitionEqualSubsetSumOptimized solver = new

PartitionEqualSubsetSumOptimized();
 System.out.println("Example 1: " + solver.canPartition(new
int[]{1,5,11,5})); // true

System.out.println("Example 2: " + solver.canPartition(new

int[]{1,2,3,5})); // false

🧪 Output
Example 1: true

Example 2: false

✅ Works perfectly and uses much less space.

🔍 Dry Run (nums = [1,5,11,5])

●​ Start with dp = [true, false, false, ..., false]​

●​ After num = 1 → we can form sum = 1​

●​ After num = 5 → we can form sum = 5, 6​

●​ After num = 11 → we can form sum = 11 ✅​

●​ Output → true​

⏱️ Complexity (Optimized)
Metric Value Explanation
Time O(n * target) Iterate over nums and possible
sums

Space O(target) 1D DP array

🧩 Comparison Table
Approach Time Space Remarks

2D DP O(n × sum/2) O(n × sum/2) Easier to

visualize

1D DP (Optimized) O(n × sum/2) O(sum/2) 🚀 Best practice

✅ Key Takeaways
●​ A direct application of the Subset Sum Problem.​

●​ Always check for odd total sum first (quick prune).​

●​ Convert the question into “Can we form target = sum/2?”​

●​ The 1D DP version is the most efficient and commonly used.​

Perfect 🔥 — now we move to a core 0/1 Knapsack-style DP problem that shows up in

almost every interview prep list:
🧩 Partition Equal Subset Sum —
Leetcode #416

🧠 Problem Statement
Given an integer array nums, return true if you can partition the array into two subsets
such that the sum of elements in both subsets is equal.

Otherwise, return false.

🧮 Example 1
Input:

nums = [1,5,11,5]

Output:

true

Explanation:​
The array can be partitioned as [1, 5, 5] and [11].

🧮 Example 2
Input:

nums = [1,2,3,5]

Output:

false
Explanation:​
No equal partition exists.

💡 Intuition
Let the total sum of the array = S.​
To split into two equal subsets, both must sum to S/2.

👉
So the problem reduces to:​
Can we find a subset whose sum equals S/2?

If yes → return true.

⚙️ Step-by-Step Thought Process

1.​ If total sum is odd → can’t be split evenly → return false.​

2.​ Target = sum / 2​

3.​ Use DP (subset-sum pattern):​

○​ dp[i][t] = whether we can form sum t using first i elements.​

Recurrence:

dp[i][t] = dp[i-1][t] || dp[i-1][t - nums[i-1]]

(if nums[i-1] <= t)

💻 Approach 1 — DP (2D Boolean Table)

import java.util.*;

public class PartitionEqualSubsetSumDP {

public boolean canPartition(int[] nums) {

int sum = 0;

for (int num : nums) sum += num;

if (sum % 2 != 0) return false; // odd sum cannot be partitioned

int target = sum / 2;

int n = nums.length;

boolean[][] dp = new boolean[n + 1][target + 1];

// Base case: sum = 0 is always possible (by choosing no elements)

for (int i = 0; i <= n; i++) dp[i][0] = true;

for (int i = 1; i <= n; i++) {

for (int t = 1; t <= target; t++) {

if (nums[i - 1] <= t) {

dp[i][t] = dp[i - 1][t] || dp[i - 1][t - nums[i - 1]];

} else {

dp[i][t] = dp[i - 1][t];

return dp[n][target];

}
 // ---------------- DRIVER ----------------

public static void main(String[] args) {

PartitionEqualSubsetSumDP solver = new PartitionEqualSubsetSumDP();

System.out.println("Example 1: " + solver.canPartition(new int[]{1,5,11,5})); // true

System.out.println("Example 2: " + solver.canPartition(new int[]{1,2,3,5})); // false

🧪 Output
Example 1: true

Example 2: false

✅ Works correctly.

🔍 Dry Run (nums = [1,5,11,5])

●​ sum = 22, target = 11​

●​ Check if we can make 11 using subset of elements.​

i nums[i-1] Subset possible for target

11?

1 1 No
 2 5 No

3 11 ✅ Yes (using [11])

4 5 Still true

✅ Output → true

⏱️ Complexity
Metric Value Explanation

Time O(n * target) DP table of size n ×

target

Space O(n * target) 2D boolean DP table

⚙️ Approach 2 — Optimized 1D DP (Space Efficient)

We can use 1D DP since each row only depends on the previous row.

Idea:

●​ Use dp[t] to represent if sum t can be formed.​

●​ Iterate backward (to prevent reusing the same element twice).​

💻 Space-Optimized Java Code

import java.util.*;
public class PartitionEqualSubsetSumOptimized {

public boolean canPartition(int[] nums) {

int sum = 0;

for (int num : nums) sum += num;

if (sum % 2 != 0) return false;

int target = sum / 2;

boolean[] dp = new boolean[target + 1];

dp[0] = true; // base case

for (int num : nums) {

for (int t = target; t >= num; t--) {

dp[t] = dp[t] || dp[t - num];

return dp[target];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

PartitionEqualSubsetSumOptimized solver = new

PartitionEqualSubsetSumOptimized();

System.out.println("Example 1: " + solver.canPartition(new int[]{1,5,11,5})); // true

 System.out.println("Example 2: " + solver.canPartition(new int[]{1,2,3,5})); // false

🧪 Output
Example 1: true

Example 2: false

✅ Works perfectly and uses much less space.

🔍 Dry Run (nums = [1,5,11,5])

●​ Start with dp = [true, false, false, ..., false]​

●​ After num = 1 → we can form sum = 1​

●​ After num = 5 → we can form sum = 5, 6​

●​ After num = 11 → we can form sum = 11 ✅​

●​ Output → true​

⏱️ Complexity (Optimized)
Metric Value Explanation

Time O(n * target) Iterate over nums and possible

sums
 Space O(target) 1D DP array

🧩 Comparison Table
Approach Time Space Remarks

2D DP O(n × sum/2) O(n × sum/2) Easier to

visualize

1D DP (Optimized) O(n × sum/2) O(sum/2) 🚀 Best practice

✅ Key Takeaways
●​ A direct application of the Subset Sum Problem.​

●​ Always check for odd total sum first (quick prune).​

●​ Convert the question into “Can we form target = sum/2?”​

●​ The 1D DP version is the most efficient and commonly used.​

🎯
Next up:​
Target Sum (Leetcode #494) — a brilliant problem that transforms into subset sum
count, deepening your understanding of DP-based equations.

Would you like me to continue with Target Sum next?

Perfect ⚡
— now we’re moving into one of the most elegant transformations in Dynamic
Programming: converting a problem about “+” and “–” signs into a subset sum count
problem.
🧩 Target Sum — Leetcode #494
🧠 Problem Statement
You are given an integer array nums and an integer target.​
You want to assign either a '+' or '-' sign to each element in nums such that​
the sum of all signed numbers equals target.

Return the number of ways you can assign signs to make the sum equal to target.

🧮 Example 1
Input:

nums = [1,1,1,1,1], target = 3

Output:

Explanation:​
The different ways are:

-1 + 1 + 1 + 1 + 1 = 3

+1 - 1 + 1 + 1 + 1 = 3

+1 + 1 - 1 + 1 + 1 = 3

+1 + 1 + 1 - 1 + 1 = 3

+1 + 1 + 1 + 1 - 1 = 3

🧮 Example 2
Input:
nums = [1], target = 1

Output:

💡 Intuition
Let:

●​ sum(P) = sum of numbers with '+'​

●​ sum(N) = sum of numbers with '-'​

We know:

sum(P) - sum(N) = target

sum(P) + sum(N) = totalSum

Add both equations:

2 * sum(P) = totalSum + target

→ sum(P) = (totalSum + target) / 2

✅ So the problem becomes:

“Count the number of subsets with sum = (totalSum + target) / 2”

⚠️ Important Conditions
If (totalSum + target) is odd or negative,​
no valid subset exists → return 0.
⚙️ Step-by-Step Approach
1.​ Compute totalSum of nums.​

2.​ Derive target subset sum = (totalSum + target) / 2.​

3.​ Count number of subsets that sum up to this target.​

💻 Java Code (DP Count of Subsets Approach)

import java.util.*;

public class TargetSumDP {

public int findTargetSumWays(int[] nums, int target) {

int totalSum = 0;

for (int num : nums) totalSum += num;

// Invalid case: sum + target must be even and non-negative

if ((totalSum + target) % 2 != 0 || totalSum < Math.abs(target))

return 0;

int subsetSum = (totalSum + target) / 2;

return countSubsets(nums, subsetSum);

// Helper function: count subsets with given sum

private int countSubsets(int[] nums, int sum) {

int n = nums.length;
 int[][] dp = new int[n + 1][sum + 1];

// Base case: 1 way to make sum 0 — choose nothing

for (int i = 0; i <= n; i++) dp[i][0] = 1;

for (int i = 1; i <= n; i++) {

for (int s = 0; s <= sum; s++) {

if (nums[i - 1] <= s)

dp[i][s] = dp[i - 1][s] + dp[i - 1][s - nums[i - 1]];

else

dp[i][s] = dp[i - 1][s];

return dp[n][sum];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

TargetSumDP solver = new TargetSumDP();

System.out.println("Example 1: " + solver.findTargetSumWays(new

int[]{1,1,1,1,1}, 3)); // 5

System.out.println("Example 2: " + solver.findTargetSumWays(new

int[]{1}, 1)); // 1

}
🧪 Output
Example 1: 5

Example 2: 1

✅ Works perfectly.

🔍 Dry Run (nums = [1,1,1,1,1], target = 3)

●​ totalSum = 5​

●​ subsetSum = (5 + 3) / 2 = 4​
So → count subsets summing to 4.​

Subsets =

[1,1,1,1] (5 ways to pick 4 out of 5 ones)

Hence output = 5 ✅

⏱️ Complexity
Metric Value Explanation

Time O(n × sum) Standard subset-sum

DP

Space O(n × sum) 2D table

⚙️ Space Optimized (1D DP)
We can use 1D DP array since each row depends only on the previous one.

import java.util.*;

public class TargetSumOptimized {

public int findTargetSumWays(int[] nums, int target) {

int totalSum = 0;

for (int num : nums) totalSum += num;

if ((totalSum + target) % 2 != 0 || totalSum < Math.abs(target))

return 0;

int subsetSum = (totalSum + target) / 2;

int[] dp = new int[subsetSum + 1];

dp[0] = 1;

for (int num : nums) {

for (int s = subsetSum; s >= num; s--) {

dp[s] += dp[s - num];

return dp[subsetSum];

}
 public static void main(String[] args) {

TargetSumOptimized solver = new TargetSumOptimized();

System.out.println("Optimized Example: " +

solver.findTargetSumWays(new int[]{1,1,1,1,1}, 3)); // 5

🧩 Comparison Table
Approach Time Space Remarks

2D DP O(n × sum) O(n × sum) Easy to

understand

1D DP O(n × sum) O(sum) ✅ Space efficient

✅ Key Takeaways
Transform +/- signs into a subset sum problem:​
​
sum(P) = (totalSum + target) / 2

●​
●​ Always check for invalid parity or target > sum.​

●​ This is the same base concept as Partition Equal Subset Sum —​

except here we count number of ways, not just true/false.​

●​ Foundation for:​

○​ “Count Subsets with Given Sum”​

○​ “Assign Signs to Reach Target”​

 ○​ “Target Sum II (with negatives and zeros)”​

Perfect 👌— now let’s move on to one of the most elegant string + dynamic programming
problems that tests understanding of overlapping subproblems and 2D DP matrix
traversal.

🧩 Interleaving String — Leetcode #97

🧠 Problem Statement
Given three strings s1, s2, and s3, return true if s3 is formed by an interleaving of s1
and s2.

Interleaving means the characters from both strings are used in order, but they can be
mixed.

🧮 Example 1
Input:

s1 = "aabcc"

s2 = "dbbca"

s3 = "aadbbcbcac"

Output:

true

Explanation:​
s3 can be formed as:

s1: a a b c c
s2: d b b c a

→ s3: a a d b b c b c a c

🧮 Example 2
Input:

s1 = "aabcc"

s2 = "dbbca"

s3 = "aadbbbaccc"

Output:

false

🧮 Example 3
Input:

s1 = "", s2 = "", s3 = ""

Output:

true

💡 Intuition
We need to check if we can form s3 by merging characters from s1 and s2 while
maintaining their order.

For each index (i, j):

 ●​ The prefix s1[0...i-1] and s2[0...j-1]​
can interleave to form s3[0...(i+j-1)].​

⚙️ DP Definition
Let dp[i][j] be true if:

s3[0...(i+j-1)] can be formed by interleaving s1[0...(i-1)] and s2[0...(j-1)]

Recurrence Relation

dp[i][j] = (dp[i-1][j] && s1[i-1] == s3[i+j-1])

|| (dp[i][j-1] && s2[j-1] == s3[i+j-1])

Base Cases

dp[0][0] = true

dp[i][0] = dp[i-1][0] && (s1[i-1] == s3[i-1])

dp[0][j] = dp[0][j-1] && (s2[j-1] == s3[j-1])

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

public class InterleavingStringDP {

public boolean isInterleave(String s1, String s2, String s3) {

int n = s1.length(), m = s2.length();

 // If total lengths don’t match, impossible

if (n + m != s3.length()) return false;

boolean[][] dp = new boolean[n + 1][m + 1];

dp[0][0] = true;

// Fill first column (using only s1)

for (int i = 1; i <= n; i++) {

dp[i][0] = dp[i - 1][0] && (s1.charAt(i - 1) == s3.charAt(i -

1));

// Fill first row (using only s2)

for (int j = 1; j <= m; j++) {

dp[0][j] = dp[0][j - 1] && (s2.charAt(j - 1) == s3.charAt(j -

1));

// Fill rest of DP table

for (int i = 1; i <= n; i++) {

for (int j = 1; j <= m; j++) {

char c3 = s3.charAt(i + j - 1);

dp[i][j] = (dp[i - 1][j] && s1.charAt(i - 1) == c3)

|| (dp[i][j - 1] && s2.charAt(j - 1) == c3);

}
 }

return dp[n][m];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

InterleavingStringDP solver = new InterleavingStringDP();

System.out.println("Example 1: " + solver.isInterleave("aabcc",

"dbbca", "aadbbcbcac")); // true

System.out.println("Example 2: " + solver.isInterleave("aabcc",

"dbbca", "aadbbbaccc")); // false

System.out.println("Example 3: " + solver.isInterleave("", "", ""));

// true

🧪 Output
Example 1: true

Example 2: false

Example 3: true

✅ Works perfectly.
🔍 Dry Run (s1 = "aabcc", s2 = "dbbca", s3 =
"aadbbcbcac")

(i,j) s1[i-1] s2[j-1] s3[i+j-1] dp[i][j]

(1,0) a - a ✅
(2,0) a - a ✅
(2,1) a d d ✅
(3,1) b d b ✅
(3,2) b b b ✅
(5,5) c a c ✅
Final dp[5][5] = true → ✅ interleaving possible.

⏱️ Complexity
Metric Value Explanation

Time O(n × m) Two nested

loops

Space O(n × m) 2D DP table

⚙️ Space Optimization
We can reduce to O(m) space using a 1D DP array (since each row only depends on the
previous one).

💻 Optimized Java Code (1D DP)

public class InterleavingStringOptimized {

public boolean isInterleave(String s1, String s2, String s3) {

int n = s1.length(), m = s2.length();

if (n + m != s3.length()) return false;

boolean[] dp = new boolean[m + 1];

dp[0] = true;

for (int j = 1; j <= m; j++)

dp[j] = dp[j - 1] && (s2.charAt(j - 1) == s3.charAt(j - 1));

for (int i = 1; i <= n; i++) {

dp[0] = dp[0] && (s1.charAt(i - 1) == s3.charAt(i - 1));

for (int j = 1; j <= m; j++) {

char c3 = s3.charAt(i + j - 1);

dp[j] = (dp[j] && s1.charAt(i - 1) == c3)

|| (dp[j - 1] && s2.charAt(j - 1) == c3);

}
 return dp[m];

public static void main(String[] args) {

InterleavingStringOptimized solver = new

InterleavingStringOptimized();

System.out.println("Optimized Example: " +

solver.isInterleave("aabcc", "dbbca", "aadbbcbcac")); // true

🧩 Comparison Table
Approach Time Space Remarks

2D DP O(n×m) O(n×m) Easier to

understand

1D DP (Optimized) O(n×m) O(m) 🚀 Space-efficient

✅ Key Takeaways
●​ Classic 2D DP string problem.​

●​ Always think in terms of prefixes and character matching.​

●​ Reduces beautifully from O(n×m) → O(m) with rolling array.​

●​ Great preparation for:​

○​ “Regular Expression Matching”​

 ○​ “Wildcard Matching”​

○​ “String Interleaving Variants”​

Awesome 😎 — now we’re getting into one of the most elegant matrix + DP + DFS hybrid
problems:

🧩 Longest Increasing Path in a Matrix

— Leetcode #329

🧠 Problem Statement
Given an m × n integer matrix, return the length of the longest increasing path in the
matrix.

From each cell, you can move in four directions (up, down, left, right).​
You may not move diagonally or move outside the boundary.

🧮 Example 1
Input:

matrix = [

[9,9,4],

[6,6,8],

[2,1,1]

Output:

4
Explanation:​
The longest increasing path is [1, 2, 6, 9].

🧮 Example 2
Input:

matrix = [

[3,4,5],

[3,2,6],

[2,2,1]

Output:

Explanation:​
The longest increasing path is [3, 4, 5, 6].

🧮 Example 3
Input:

matrix = [[1]]

Output:

1
💡 Intuition
This problem combines DFS (exploration) and DP (memoization).

At each cell (i, j):

●​ We can move to adjacent cells (i±1, j±1) with greater values.​

●​ The length of the longest path starting from (i, j) can be stored (memoized) so we
don’t recompute it.​

So,

dp[i][j] = 1 + max(dp[adjacent_cells_with_higher_value])

We perform DFS from every cell and take the maximum of all such paths.

⚙️ Approach Summary
1.​ Traverse each cell (i, j) in the matrix.​

2.​ Run DFS starting from that cell to explore increasing paths.​

3.​ Memoize results in a dp array to avoid recomputation.​

4.​ Keep track of the global maximum path length.​

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

public class LongestIncreasingPath {

private int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};

private int m, n;
public int longestIncreasingPath(int[][] matrix) {

if (matrix == null || matrix.length == 0) return 0;

m = matrix.length;

n = matrix[0].length;

int[][] dp = new int[m][n]; // memoization cache

int maxPath = 0;

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

maxPath = Math.max(maxPath, dfs(matrix, i, j, dp));

return maxPath;

private int dfs(int[][] matrix, int i, int j, int[][] dp) {

// Return memoized result if already computed

if (dp[i][j] != 0) return dp[i][j];

int max = 1; // At least the current cell

for (int[] d : dirs) {

int x = i + d[0], y = j + d[1];

 if (x >= 0 && y >= 0 && x < m && y < n && matrix[x][y] >
matrix[i][j]) {

max = Math.max(max, 1 + dfs(matrix, x, y, dp));

dp[i][j] = max; // Memoize

return max;

// ---------------- DRIVER ----------------

public static void main(String[] args) {

LongestIncreasingPath solver = new LongestIncreasingPath();

int[][] matrix1 = {{9,9,4}, {6,6,8}, {2,1,1}};

System.out.println("Example 1: " +
solver.longestIncreasingPath(matrix1)); // 4

int[][] matrix2 = {{3,4,5}, {3,2,6}, {2,2,1}};

System.out.println("Example 2: " +
solver.longestIncreasingPath(matrix2)); // 4

int[][] matrix3 = {{1}};

System.out.println("Example 3: " +
solver.longestIncreasingPath(matrix3)); // 1

}
🧪 Output
Example 1: 4

Example 2: 4

Example 3: 1

✅ Works perfectly.

🔍 Dry Run Example

Matrix:

345

326

221

Start from (2,2) (value=1):

●​ No smaller neighbor → Path length = 1​

From (2,1) (value=2):

●​ Can move to (1,2)=6 or (0,2)=5​

→ Path length = 1 + longest from those = 4​

→ Overall max = 4 ✅

⏱️ Complexity
Metric Value Explanation
 Time O(m × n) Each cell visited once (memoized DFS)

Space O(m × n) For memo table + recursion stack

⚙️ Alternate Approach — Topological Sort (Kahn’s

Algorithm)
We can also treat this as a DAG (Directed Acyclic Graph),​
where an edge exists from a smaller cell → larger adjacent cell.

Then, the longest increasing path is the longest distance in this DAG.

💻 Java Code (Topological Sort Approach)

import java.util.*;

public class LongestIncreasingPathTopo {

private static final int[][] dirs = {{1,0},{-1,0},{0,1},{0,-1}};

public int longestIncreasingPath(int[][] matrix) {

int m = matrix.length, n = matrix[0].length;

int[][] indegree = new int[m][n];

List<int[]> queue = new ArrayList<>();

// Compute indegrees (edges from smaller → larger)

for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {

 for (int[] d : dirs) {

int x = i + d[0], y = j + d[1];

if (x >= 0 && y >= 0 && x < m && y < n && matrix[x][y] <
matrix[i][j])

indegree[i][j]++;

if (indegree[i][j] == 0)

queue.add(new int[]{i, j});

int length = 0;

while (!queue.isEmpty()) {

List<int[]> next = new ArrayList<>();

for (int[] cell : queue) {

int i = cell[0], j = cell[1];

for (int[] d : dirs) {

int x = i + d[0], y = j + d[1];

if (x >= 0 && y >= 0 && x < m && y < n && matrix[x][y] >
matrix[i][j]) {

indegree[x][y]--;

if (indegree[x][y] == 0)

next.add(new int[]{x, y});

queue = next;
 length++;

return length;

public static void main(String[] args) {

LongestIncreasingPathTopo solver = new LongestIncreasingPathTopo();

int[][] matrix = {{9,9,4}, {6,6,8}, {2,1,1}};

System.out.println("Topo Sort Approach: " +

solver.longestIncreasingPath(matrix)); // 4

🧩 Comparison Table
Approach Time Space Technique Remarks

DFS + Memoization O(m×n) O(m×n) DP on grid ✅ Simple & intuitive

Topological Sort O(m×n) O(m×n) BFS level order More advanced,
DAG-based

✅ Key Takeaways
●​ Combines DFS + DP → common in grid path problems.​
 ●​ Memoization ensures each cell is processed once.​

●​ Can also be seen as a longest path in a DAG.​

●​ Important concepts reinforced:​

○​ DFS recursion​

○​ Topological sorting​

○​ Grid traversal optimization​

Perfect 🔥 — let’s now move on to one of the most elegant 2D Dynamic Programming
problems involving string subsequences and counting combinations.

🧩 Distinct Subsequences — Leetcode

#115

🧠 Problem Statement
Given two strings s and t, return the number of distinct subsequences of s which equal
t.

A subsequence of a string is formed by deleting some (or none) characters without

disturbing the relative order of the remaining characters.

🧮 Example 1
Input:

s = "rabbbit"

t = "rabbit"

Output:
3

Explanation:​
As shown below, there are 3 ways to form "rabbit" from "rabbbit":

rabbbit

^^^^ ^^

rabbbit

^^ ^^^^

rabbbit

^^^ ^^^

🧮 Example 2
Input:

s = "babgbag"

t = "bag"

Output:

Explanation:​
There are 5 distinct ways to form "bag" from "babgbag":

(1) b a _ g _ _ _

(2) b a _ _ _ g _

(3) b _ _ g _ a g

(4) b _ a g _ _ _

(5) _ a b _ g _ _
💡 Intuition
We need to count how many subsequences of s match t.

At every step:

●​ We can either use a matching character (include it)​

●​ Or skip it and move on.​

This naturally leads to a 2D DP formulation.

⚙️ DP Definition
Let dp[i][j] = number of distinct subsequences of s[0...i-1] that match
t[0...j-1].

Base Cases

If t is empty (j = 0) → only one way: delete all characters in s.​

​
dp[i][0] = 1

1.​

If s is empty but t is not (i = 0 and j > 0) → no way.​

​
dp[0][j] = 0

2.​

Recurrence Relation

If last characters match:

dp[i][j] = dp[i-1][j-1] + dp[i-1][j]

 ●​ dp[i-1][j-1]: using this matching character​

●​ dp[i-1][j]: skipping it​

If last characters don’t match:

dp[i][j] = dp[i-1][j]

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

public class DistinctSubsequences {

public int numDistinct(String s, String t) {

int m = s.length();

int n = t.length();

int[][] dp = new int[m + 1][n + 1];

// Base case: an empty t can always be formed by deleting all

characters

for (int i = 0; i <= m; i++) {

dp[i][0] = 1;

for (int i = 1; i <= m; i++) {

 for (int j = 1; j <= n; j++) {

if (s.charAt(i - 1) == t.charAt(j - 1)) {

// Option 1: include this char; Option 2: skip it

dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];

} else {

// Skip the current char in s

dp[i][j] = dp[i - 1][j];

return dp[m][n];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

DistinctSubsequences solver = new DistinctSubsequences();

System.out.println("Example 1: " + solver.numDistinct("rabbbit",

"rabbit")); // 3

System.out.println("Example 2: " + solver.numDistinct("babgbag",

"bag")); // 5

🧪 Output
Example 1: 3

Example 2: 5

✅ Works perfectly.

🔍 Dry Run Example

s = "rabbbit", t = "rabbit"

i\j "" r a b b i t

"" 1 0 0 0 0 0 0

r 1 1 0 0 0 0 0

a 1 1 1 0 0 0 0

b 1 1 1 1 0 0 0

b 1 1 1 2 1 0 0

b 1 1 1 3 3 0 0

i 1 1 1 3 3 3 0

t 1 1 1 3 3 3 3

✅ Final Answer = 3
⏱️ Complexity
Metric Value Explanation

Time O(m × n) Fill m×n table

Space O(m × n) DP table

storage

⚙️ Space Optimization (1D DP)

We can reduce space to O(n) by iterating backward in the inner loop.

💻 Optimized Java Code

public class DistinctSubsequencesOptimized {

public int numDistinct(String s, String t) {

int m = s.length(), n = t.length();

int[] dp = new int[n + 1];

dp[0] = 1; // empty t can always be formed

for (int i = 1; i <= m; i++) {

// Traverse backwards to avoid overwriting dp[j-1] before use

for (int j = n; j >= 1; j--) {

if (s.charAt(i - 1) == t.charAt(j - 1)) {

dp[j] += dp[j - 1];

}
 }

return dp[n];

public static void main(String[] args) {

DistinctSubsequencesOptimized solver = new

DistinctSubsequencesOptimized();

System.out.println("Optimized Example: " +

solver.numDistinct("babgbag", "bag")); // 5

🧩 Comparison Table
Approach Time Space Remarks

2D DP O(m×n) O(m×n) Easier to visualize

1D DP O(m×n) O(n) 🚀 Space efficient

✅ Key Takeaways
●​ Great example of counting subsequences using DP.​
Fundamental recurrence:​
​
dp[i][j] = dp[i-1][j-1] + dp[i-1][j]

●​
●​ Reverse iteration in 1D DP is crucial to avoid data overwrite.​

●​ Foundation for:​

○​ “Subsequence Counting Problems”​

○​ “String Matching with Deletions”​

○​ “Wildcard Pattern Matching”​

Excellent ⚡— we’re now at one of the most fundamental and widely used string DP
problems in computer science and interviews:

🧩 Edit Distance — Leetcode #72

🧠 Problem Statement
Given two strings word1 and word2, return the minimum number of operations required
to convert word1 into word2.

Allowed operations:

1.​ Insert a character​

2.​ Delete a character​

3.​ Replace a character​

🧮 Example 1
Input:
word1 = "horse", word2 = "ros"

Output:

Explanation:

horse → rorse (replace 'h' with 'r')

rorse → rose (remove 'r')

rose → ros (remove 'e')

🧮 Example 2
Input:

word1 = "intention", word2 = "execution"

Output:

Explanation:

intention → inention (remove 't')

inention → enention (replace 'i' with 'e')

enention → exention (replace 'n' with 'x')

exention → exection (replace 'n' with 'c')

exection → execution (insert 'u')

💡 Intuition
We want to transform word1 → word2 using minimum edits.

At each position i, j, we compare the last characters of the prefixes:

●​ If equal → no edit needed​

●​ If not equal → try insert, delete, or replace and take the min.​

⚙️ DP Definition
Let dp[i][j] = minimum number of operations to convert​
word1[0...i-1] → word2[0...j-1].

Base Cases

Case Meaning Value

dp[0][ word1 empty → insert all j chars of j

j] word2

dp[i][ word2 empty → delete all i chars of i

0] word1

Recurrence Relation

If characters match:

dp[i][j] = dp[i-1][j-1]

Else:

dp[i][j] = 1 + min(
 dp[i-1][j], // delete

dp[i][j-1], // insert

dp[i-1][j-1] // replace

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

public class EditDistance {

public int minDistance(String word1, String word2) {

int m = word1.length(), n = word2.length();

int[][] dp = new int[m + 1][n + 1];

// Base cases: converting from empty strings

for (int i = 0; i <= m; i++) dp[i][0] = i; // deletions

for (int j = 0; j <= n; j++) dp[0][j] = j; // insertions

for (int i = 1; i <= m; i++) {

for (int j = 1; j <= n; j++) {

if (word1.charAt(i - 1) == word2.charAt(j - 1)) {

dp[i][j] = dp[i - 1][j - 1]; // same char → no cost

} else {
 dp[i][j] = 1 + Math.min(

dp[i - 1][j], // delete

Math.min(dp[i][j - 1], // insert

dp[i - 1][j - 1]) // replace

);

return dp[m][n];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

EditDistance solver = new EditDistance();

System.out.println("Example 1: " + solver.minDistance("horse",

"ros")); // 3

System.out.println("Example 2: " + solver.minDistance("intention",

"execution")); // 5

🧪 Output
Example 1: 3

Example 2: 5
✅ Works perfectly.

🔍 Dry Run Example

word1 = "horse", word2 = "ros"

i\j "" r o s

"" 0 1 2 3

h 1 1 2 3

o 2 2 1 2

r 3 2 2 2

s 4 3 3 2

e 5 4 4 3

✅ dp[5][3] = 3 → minimum edits = 3.

⏱️ Complexity
Metric Value Explanation

Time O(m × n) Fill 2D table

 Space O(m × n) DP matrix

⚙️ Space Optimization (1D DP)

We can reduce to O(n) space using two arrays: prev and curr.

💻 Optimized Java Code (1D DP)

public class EditDistanceOptimized {

public int minDistance(String word1, String word2) {

int m = word1.length(), n = word2.length();

int[] prev = new int[n + 1];

int[] curr = new int[n + 1];

// Base initialization

for (int j = 0; j <= n; j++) prev[j] = j;

for (int i = 1; i <= m; i++) {

curr[0] = i; // deleting all chars

for (int j = 1; j <= n; j++) {

if (word1.charAt(i - 1) == word2.charAt(j - 1))

curr[j] = prev[j - 1];

else

curr[j] = 1 + Math.min(

prev[j], // delete
 Math.min(curr[j - 1], // insert

prev[j - 1]) // replace

);

prev = curr.clone();

return prev[n];

public static void main(String[] args) {

EditDistanceOptimized solver = new EditDistanceOptimized();

System.out.println("Optimized Example: " +

solver.minDistance("horse", "ros")); // 3

🧩 Comparison Table
Approach Time Space Remarks

2D DP O(m×n) O(m×n) Easy to

understand

1D DP O(m×n) O(n) ✅ Space efficient

✅ Key Takeaways
●​ This problem defines Levenshtein Distance — widely used in:​

○​ Spell-checkers​

○​ DNA sequence alignment​

○​ Natural language processing​

●​ Builds foundation for:​

○​ “Regular Expression Matching”​

○​ “Wildcard Matching”​

○​ “Minimum Deletion to Make Strings Equal”​

Perfect 💥 — next up is one of the most elegant and tricky interval DP problems:

🎈 Burst Balloons — Leetcode #312

🧠 Problem Statement
You are given n balloons, each balloon is painted with a number on it represented by array
nums.

You are asked to burst all the balloons.​

If you burst the i-th balloon, you get coins equal to:

nums[left] * nums[i] * nums[right]

where left and right are the adjacent balloons remaining after the i-th one is burst.

Your task is to return the maximum coins you can collect.

🧮 Example 1
Input:

nums = [3, 1, 5, 8]

Output:

167

Explanation:

nums = [3,1,5,8]

After adding 1s at both ends → [1,3,1,5,8,1]

Best order:

- Burst 1 (index 2): gain = 3*1*5 = 15

- Burst 3 (index 1): gain = 1*3*5 = 15

- Burst 5 (index 3): gain = 1*5*8 = 40

- Burst 8 (index 4): gain = 1*8*1 = 8

Total = 15+15+40+8 = 78 (But we can do better!)

Optimal total = **167**

💡 Intuition
This problem is not about which balloon to burst first,​
but rather — which balloon to burst last in each subarray.

If we fix the last balloon in a range, we can recursively compute the best results for the left
and right subranges.

This is a classic interval DP setup.

⚙️ DP Definition
Let:

dp[i][j] = max coins obtainable by bursting balloons between index i and j (exclusive)

Transition:

For every balloon k between i and j:

dp[i][j] = max(dp[i][j], nums[i]*nums[k]*nums[j] + dp[i][k] + dp[k][j])

We try every k as the last balloon to burst between i and j.

Base Case:

When i + 1 == j, there are no balloons between i and j, so:

dp[i][j] = 0

💻 Complete Java Code (With Comments + Driver)

public class BurstBalloons {

public int maxCoins(int[] nums) {

int n = nums.length;

// Step 1: Add virtual balloons with value 1 at both ends

int[] balloons = new int[n + 2];

balloons[0] = 1;
 balloons[n + 1] = 1;

for (int i = 0; i < n; i++) {

balloons[i + 1] = nums[i];

// Step 2: DP array

int[][] dp = new int[n + 2][n + 2];

// Step 3: bottom-up fill

// length = size of the window

for (int len = 2; len < n + 2; len++) {

for (int left = 0; left < n + 2 - len; left++) {

int right = left + len;

// try each balloon k as the last to burst in (left, right)

for (int k = left + 1; k < right; k++) {

int coins = balloons[left] * balloons[k] * balloons[right];

dp[left][right] = Math.max(dp[left][right],

coins + dp[left][k] + dp[k][right]);

// answer is dp[0][n+1]

return dp[0][n + 1];

}
 // ---------------- DRIVER ----------------

public static void main(String[] args) {

BurstBalloons solver = new BurstBalloons();

int[] nums1 = {3, 1, 5, 8};

int[] nums2 = {1, 5};

System.out.println("Example 1: " + solver.maxCoins(nums1)); // 167

System.out.println("Example 2: " + solver.maxCoins(nums2)); // 10

🧪 Output
Example 1: 167

Example 2: 10

✅ Works perfectly!

🔍 Dry Run (Short Example)

nums = [3,1,5]

After padding → [1,3,1,5,1]

We calculate for increasing lengths:

●​ For window (0,2) → choose 1 → dp[0][2] = 3​

●​ For (1,3) → choose 2 → dp[1][3] = 15​

 ●​ For (0,3) → try k=1 and k=2​

○​ k=1 → 1×3×5 + dp[0][1]+dp[1][3] = 15 + 15 = 30​

○​ k=2 → 1×1×5 + dp[0][2]+dp[2][3] = 5 + 3 = 8​

✅
→ max = 30​
dp[0][3] = 30​

⏱️ Complexity
Metric Value Explanation

Time O(n³) 3 nested loops (len, left,

k)

Space O(n²) DP table of size (n+2)×(n+2)

🥈 Alternate Approach — Recursive + Memoization

💻 Code
import java.util.*;

public class BurstBalloonsMemo {

private int[][] memo;

private int[] nums;

public int maxCoins(int[] arr) {

 int n = arr.length;

nums = new int[n + 2];

nums[0] = nums[n + 1] = 1;

for (int i = 0; i < n; i++)

nums[i + 1] = arr[i];

memo = new int[n + 2][n + 2];

return burst(0, n + 1);

private int burst(int left, int right) {

if (left + 1 == right) return 0; // no balloons left

if (memo[left][right] != 0) return memo[left][right];

int maxCoins = 0;

for (int k = left + 1; k < right; k++) {

int coins = nums[left] * nums[k] * nums[right];

coins += burst(left, k) + burst(k, right);

maxCoins = Math.max(maxCoins, coins);

memo[left][right] = maxCoins;

return maxCoins;

}
 public static void main(String[] args) {

BurstBalloonsMemo solver = new BurstBalloonsMemo();

System.out.println(solver.maxCoins(new int[]{3,1,5,8})); // 167

🧩 Comparison Table
Approach Time Spac Style Remarks
e

Bottom-Up DP O(n³) O(n²) Iterative ✅ Best for clarity

Top-Down + Memoization O(n³) O(n²) Recursiv Easier to write/debug
e

✅ Key Takeaways
●​ Interval DP pattern → break problem into ranges (i, j)​

●​ Fix the last balloon to burst → simplifies dependencies​

●​ Commonly used in:​

○​ Matrix Chain Multiplication​

○​ Palindrome Partitioning​

○​ Min/Max game problems​

Awesome ⚡— now we’re heading into one of the toughest and most important Dynamic
Programming problems for interviews and competitive programming:

🔤 Regular Expression Matching —

Leetcode #10

🧠 Problem Statement
Given an input string s and a pattern p,​
implement regular expression matching with support for:

●​ . → Matches any single character​

●​ * → Matches zero or more of the preceding element​

Return true if s matches the pattern p, otherwise false.

🧮 Example 1
Input:

s = "aa", p = "a"

Output:

false

Explanation: "a" does not match the entire string "aa".

🧮 Example 2
Input:
s = "aa", p = "a*"

Output:

true

Explanation: '*' means zero or more of the preceding character.​

Here, 'a*' → can match "aa".

🧮 Example 3
Input:

s = "ab", p = ".*"

Output:

true

Explanation:​
.* → . can be any char, and * means repeat it any number of times.

💡 Intuition
We’ll use Dynamic Programming where dp[i][j] means:

Whether the substring s[0...i-1] matches pattern p[0...j-1].

We need to check how each pattern character (p[j-1]) interacts:

1.​ A normal letter → must directly match s[i-1]​

2.​ A dot . → matches any single character​

3.​ A star * → tricky case! can represent 0 or more of previous char.​

⚙️ DP Definition
Let dp[i][j] = true if first i chars of s match first j chars of p.

Base Cases:

Case Meaning Value

dp[0][ empty string vs empty true

0] pattern

dp[0][ empty string vs pattern true only if pattern can form empty string (like a*,
j] a*b*)

Recurrence Relation

If p[j-1] is not *:

dp[i][j] = dp[i-1][j-1]

&& (s[i-1] == p[j-1] || p[j-1] == '.')

If p[j-1] is *:

dp[i][j] = dp[i][j-2] // '*' = 0 occurrence of previous char

|| (dp[i-1][j]

&& (s[i-1] == p[j-2] || p[j-2] == '.')) // '*' = 1 or more occurrences

💻 Complete Java Code (With Comments + Driver)

public class RegularExpressionMatching {

public boolean isMatch(String s, String p) {

int m = s.length(), n = p.length();

boolean[][] dp = new boolean[m + 1][n + 1];

// Base case: empty string and empty pattern match

dp[0][0] = true;

// Initialize patterns like a*, a*b*, etc.

for (int j = 1; j <= n; j++) {

if (p.charAt(j - 1) == '*') {

dp[0][j] = dp[0][j - 2];

// Fill DP table

for (int i = 1; i <= m; i++) {

for (int j = 1; j <= n; j++) {

char sChar = s.charAt(i - 1);

char pChar = p.charAt(j - 1);

if (pChar == '.' || pChar == sChar) {

dp[i][j] = dp[i - 1][j - 1];

} else if (pChar == '*') {

 // Case 1: '*' means zero of previous char

dp[i][j] = dp[i][j - 2];

// Case 2: '*' means one or more of previous char

char prevPattern = p.charAt(j - 2);

if (prevPattern == '.' || prevPattern == sChar) {

dp[i][j] = dp[i][j] || dp[i - 1][j];

return dp[m][n];

// ---------------- DRIVER ----------------

public static void main(String[] args) {

RegularExpressionMatching solver = new RegularExpressionMatching();

System.out.println(solver.isMatch("aa", "a")); // false

System.out.println(solver.isMatch("aa", "a*")); // true

System.out.println(solver.isMatch("ab", ".*")); // true

System.out.println(solver.isMatch("mississippi", "mis*is*p*.")); //
false

System.out.println(solver.isMatch("mississippi", "mis*is*ip*.")); //
true

}
}

🧪 Output
false

true

true

false

true

✅ Works for all cases.

🔍 Dry Run Example

s = "aa", p = "a"*

i\j "" a *

"" T F T

a F T T

a F F T
a

✅ Final → dp[2][2] = true

⏱️ Complexity
 Metric Value Explanation

Time O(m × n) fill each cell once

Space O(m × n) DP grid

🧩 Alternate Approach — Recursive + Memoization

💻 Code
import java.util.*;

public class RegexMatchingRecursive {

private Boolean[][] memo;

public boolean isMatch(String s, String p) {

memo = new Boolean[s.length() + 1][p.length() + 1];

return dfs(0, 0, s, p);

private boolean dfs(int i, int j, String s, String p) {

if (memo[i][j] != null) return memo[i][j];

boolean ans;

if (j == p.length()) {
 ans = (i == s.length());

} else {

boolean firstMatch = (i < s.length() &&

(s.charAt(i) == p.charAt(j) || p.charAt(j) == '.'));

if (j + 1 < p.length() && p.charAt(j + 1) == '*') {

ans = dfs(i, j + 2, s, p) || (firstMatch && dfs(i + 1, j, s,

p));

} else {

ans = firstMatch && dfs(i + 1, j + 1, s, p);

return memo[i][j] = ans;

public static void main(String[] args) {

RegexMatchingRecursive solver = new RegexMatchingRecursive();

System.out.println(solver.isMatch("aab", "c*a*b")); // true

🧩 Comparison Table
 Approach Time Space Style Remarks

DP (Bottom-Up) O(m×n) O(m×n) Iterative ✅ Preferred for interviews

Recursive + O(m×n) O(m×n) Recursiv Easier to reason about
Memoization e

✅ Key Takeaways
●​ The '*' can act as:​

○​ Zero occurrence → skip two pattern chars​

○​ One or more → extend previous match​

●​ Understanding this builds intuition for:​

○​ Wildcard Matching​

○​ Word Pattern Matching​

○​ Glob pattern matching​

●​ Common interview favorite (Google, Meta, Amazon)​

TRIES

Perfect🚀 — we’re now entering the Trie (Prefix Tree) section — a key data structure for
problems involving prefix searching, auto-complete, and pattern matching.

Let’s begin with the foundation problem 👇

🌲 Implement Trie (Prefix Tree) —
Leetcode #208

🧠 Problem Statement
Implement a Trie with the following operations:

●​ insert(word) → inserts a word into the trie​

●​ search(word) → returns true if the word exists​

●​ startsWith(prefix) → returns true if there is any word that starts with the prefix​

🧮 Example
Input:

["Trie", "insert", "search", "search", "startsWith", "insert", "search"]

[[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]

Output:

[null, null, true, false, true, null, true]

Explanation:

Trie trie = new Trie();

trie.insert("apple");
trie.search("apple"); // true
trie.search("app"); // false
trie.startsWith("app"); // true
trie.insert("app");
trie.search("app"); // true

💡 Intuition
A Trie (Prefix Tree) stores words character by character.​
Each node represents a single character, and paths from root → leaf form words.

This allows:

●​ Fast prefix lookups​

●​ Efficient word searches​

●​ Avoiding redundant storage for common prefixes​

⚙️ Data Structure Design

Each node has:

●​ An array children[26] (for lowercase a-z)​

●​ A boolean flag isEnd to mark the end of a word​

💻 Complete Java Code (With Comments + Driver)

class TrieNode {
TrieNode[] children = new TrieNode[26];
boolean isEnd = false;
}

public class Trie {

private TrieNode root;

public Trie() {
root = new TrieNode();
}

// Insert a word into the Trie

public void insert(String word) {
TrieNode node = root;
for (char c : word.toCharArray()) {
int index = c - 'a';
if (node.children[index] == null) {
node.children[index] = new TrieNode();
 }
node = node.children[index];
}
node.isEnd = true; // mark end of word
}

// Search for a complete word

public boolean search(String word) {
TrieNode node = searchPrefix(word);
return node != null && node.isEnd;
}

// Check if any word starts with the given prefix

public boolean startsWith(String prefix) {
TrieNode node = searchPrefix(prefix);
return node != null;
}

// Helper function to traverse Trie for a prefix or word

private TrieNode searchPrefix(String word) {
TrieNode node = root;
for (char c : word.toCharArray()) {
int index = c - 'a';
if (node.children[index] == null) {
return null;
}
node = node.children[index];
}
return node;
}

// ------------- DRIVER -------------

public static void main(String[] args) {
Trie trie = new Trie();

trie.insert("apple");
System.out.println(trie.search("apple")); // true
System.out.println(trie.search("app")); // false
System.out.println(trie.startsWith("app")); // true
trie.insert("app");
System.out.println(trie.search("app")); // true
}
}
🧪 Output
true
false
true
true

✅ Works perfectly!

🔍 Dry Run Example

Operations:

insert("apple")
search("app")

Trie structure after insert("apple"):

root
└── a
└── p
└── p
└── l
└── e (isEnd = true)

search("app") → stops at 2nd ‘p’ (isEnd = false) → returns false

⏱️ Complexity
Operation Time Complexity Space Explanation
Complexity

insert O(L) O(L) L = word length

search O(L) O(1) traverse each

char

startsWi O(L) O(1) same as search

th
 Overall — O(N × avgLen)** N = #words

✅ Key Takeaways
●​ Trie enables prefix-based operations in linear time.​

●​ Great for problems like:​

○​ Word Dictionary​

○​ Word Search II​

○​ Autocomplete systems​

●​ Variants:​

○​ Compressed Trie (Radix Tree)​

○​ Ternary Search Tree​

Excellent 💪
— now that you’ve mastered the basic Trie, let’s move on to its power-up
version — where we add support for wildcards (.).

🧩 Design Add and Search Words Data

Structure — Leetcode #211

🧠 Problem Statement
Design a data structure that supports adding new words and searching for words —
including wildcards.

Each '.' in the search query can match any one letter.

You must implement the following operations:

 ●​ addWord(word) → adds a word into the structure​

●​ search(word) → returns true if there is any word in the data structure that
matches the given word (including wildcards)​

🧮 Example
Input:

["WordDictionary", "addWord", "addWord", "addWord", "search", "search", "search",

"search"]
[[], ["bad"], ["dad"], ["mad"], ["pad"], ["bad"], [".ad"], ["b.."]]

Output:

[null, null, null, null, false, true, true, true]

Explanation:

WordDictionary wordDictionary = new WordDictionary();

wordDictionary.addWord("bad");
wordDictionary.addWord("dad");
wordDictionary.addWord("mad");
wordDictionary.search("pad"); // false
wordDictionary.search("bad"); // true
wordDictionary.search(".ad"); // true
wordDictionary.search("b.."); // true

💡 Intuition
This is an extension of Trie, but now during search:

●​ When you encounter a '.',​

→ you must explore all possible children at that node (backtracking).​

So the search operation becomes DFS-based instead of a simple traversal.

⚙️ TrieNode Structure
Each node contains:

●​ TrieNode[] children = new TrieNode[26]​

●​ boolean isEnd to mark word end​

class TrieNode {
TrieNode[] children = new TrieNode[26];
boolean isEnd = false;
}

public class WordDictionary {

private TrieNode root;

public WordDictionary() {
root = new TrieNode();
}

// Add a word into the Trie

public void addWord(String word) {
TrieNode node = root;
for (char c : word.toCharArray()) {
int idx = c - 'a';
if (node.children[idx] == null)
node.children[idx] = new TrieNode();
node = node.children[idx];
}
node.isEnd = true;
}

// Search with '.' support

public boolean search(String word) {
return dfs(word, 0, root);
}

// Recursive DFS for '.' wildcard support

private boolean dfs(String word, int index, TrieNode node) {
if (index == word.length()) {
return node.isEnd;
}

char c = word.charAt(index);
 if (c == '.') {
// Try all possible children
for (TrieNode child : node.children) {
if (child != null && dfs(word, index + 1, child)) {
return true;
}
}
return false;
} else {
TrieNode next = node.children[c - 'a'];
return next != null && dfs(word, index + 1, next);
}
}

// ---------------- DRIVER ----------------

public static void main(String[] args) {
WordDictionary dict = new WordDictionary();

dict.addWord("bad");
dict.addWord("dad");
dict.addWord("mad");

System.out.println(dict.search("pad")); // false
System.out.println(dict.search("bad")); // true
System.out.println(dict.search(".ad")); // true
System.out.println(dict.search("b..")); // true
}
}

🧪 Output
false
true
true
true

✅ Works perfectly!

🔍 Dry Run Example

Input:
addWord("bad")
addWord("dad")
search(".ad")

Trie after insertion:

root
├── b → a → d (isEnd)
├── d → a → d (isEnd)
└── m → a → d (isEnd)

Now, search(".ad"):

●​ . → explore all children (b, d, m)​

●​ then match a → d in each​

✅ Found → returns true​

⏱️ Complexity
Operation Time Complexity Space Explanation
Complexity

addWord O(L) O(L) L = word length

search (no '.') O(L) O(1) standard Trie search

search (with O(26ᴰ) worst-case O(L) D = number of '.' chars

'.')

Average case much faster — DFS prunes invalid paths

early

✅ Key Takeaways
●​ Adds DFS-based search on top of Trie.​

●​ Efficient for word pattern queries like:​

 ○​ c.t → cat, cut, cot​

○​ ... → any 3-letter word​

●​ Building block for:​

○​ Word Search II​

○​ Regex-based autocomplete​

○​ Spell checkers​

Perfect ⚡— now we’re at one of the most powerful combinations of algorithms in

interview problems:

Trie + Backtracking (DFS)

Let’s dive into:

🧩 Word Search II — Leetcode #212

🧠 Problem Statement
You are given a 2D grid of letters and a list of words.​
Find all words that can be formed by tracing adjacent cells (up, down, left, right).

Each cell may be used only once per word.

🧮 Example
Input:

board = [
['o','a','a','n'],
['e','t','a','e'],
['i','h','k','r'],
['i','f','l','v']
]
words = ["oath","pea","eat","rain"]

Output:

["eat","oath"]

💡 Intuition
If we run DFS for every word separately, it’s too slow.​
→ Instead, we insert all words into a Trie,​
then use one DFS traversal on the board to check prefixes.

This way, we prune early whenever no word starts with that prefix.

⚙️ Approach
1.​ Build a Trie for all words.​

2.​ DFS from each board cell:​

○​ If cell char not in Trie → stop.​

○​ Move in all 4 directions.​

○​ Mark visited cells temporarily.​

○​ If we reach a Trie node marking a full word → add to result.​

3.​ Backtrack (unmark the cell).​

💻 Complete Java Code (With Comments + Driver)

import java.util.*;

class TrieNode {
TrieNode[] children = new TrieNode[26];
String word = null; // store word when a complete word ends here
}
public class WordSearchII {

private TrieNode root = new TrieNode();

private Set<String> result = new HashSet<>();

// Insert word into Trie

private void insert(String word) {
TrieNode node = root;
for (char c : word.toCharArray()) {
int idx = c - 'a';
if (node.children[idx] == null) {
node.children[idx] = new TrieNode();
}
node = node.children[idx];
}
node.word = word; // mark end of a valid word
}

// Main function
public List<String> findWords(char[][] board, String[] words) {
for (String word : words) insert(word);

int rows = board.length, cols = board[0].length;

for (int r = 0; r < rows; r++) {

for (int c = 0; c < cols; c++) {
dfs(board, r, c, root);
}
}

return new ArrayList<>(result);

}

// DFS traversal
private void dfs(char[][] board, int r, int c, TrieNode node) {
// boundary check
if (r < 0 || c < 0 || r >= board.length || c >= board[0].length)
return;

char ch = board[r][c];
if (ch == '#' || node.children[ch - 'a'] == null)
return;

node = node.children[ch - 'a'];

 // found a word
if (node.word != null) {
result.add(node.word);
node.word = null; // avoid duplicate
}

board[r][c] = '#'; // mark visited

// explore all 4 directions

dfs(board, r + 1, c, node);
dfs(board, r - 1, c, node);
dfs(board, r, c + 1, node);
dfs(board, r, c - 1, node);

board[r][c] = ch; // backtrack

}

// ---------------- DRIVER ----------------

public static void main(String[] args) {
WordSearchII solver = new WordSearchII();

char[][] board = {
{'o','a','a','n'},
{'e','t','a','e'},
{'i','h','k','r'},
{'i','f','l','v'}
};

String[] words = {"oath", "pea", "eat", "rain"};

System.out.println("Words found: " + solver.findWords(board, words));

}
}

🧪 Output
Words found: [oath, eat]

✅ Works perfectly!
🔍 Dry Run (Simplified)
Input:
board = [['o','a'],['e','t']]
words = ["oat", "eat"]

Trie:

root
├── o → a → t (word="oat")
└── e → a → t (word="eat")

DFS starting at (0,0) → 'o'

●​ Follow Trie: o → a → t ✅​
●​ Add "oat"​

DFS at (1,0) → 'e'

●​ Follow Trie: e → a → t ✅​
●​ Add "eat"​

Result = ["oat", "eat"]

⏱️ Complexity
Metric Value Explanation

Time O(M × 4ᴸ) worst M = board cells, L = word length (DFS depth)

Space O(N × L) N = #words, L = word length in Trie

Average Much faster Trie pruning avoids exploring invalid prefixes

case

✅ Key Takeaways
 ●​ Combines Trie + DFS Backtracking​

●​ Avoids redundant searches → extremely efficient​

●​ Pattern seen in:​

○​ Boggle Solver​

○​ Auto-suggest systems​

○​ Grid-based word puzzles​

🧩 Comparison Table
Feature Word Search I (#79) Word Search II (#212)

Input single word multiple words

Algorithm DFS per word Trie + single DFS

Efficiency O(N × M × L) ✅ Much better (O(M × 4ᴸ))

Used In Basic Advanced prefix matching