Add solutions and explanations for problems 27, 156, 157, 158, 159, 161, 163, 170

Author: vikahaze

books/All.md

@@ -0,0 +1,56 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to flip a binary tree upside down, where the original leftmost node becomes the new root, and the original root becomes the rightmost leaf. The transformation follows a specific pattern where left children become parents and right children become left children.
+
+**1.1 Constraints & Complexity:**
+- Input size: The tree can have up to O(n) nodes where n is the number of nodes
+- **Time Complexity:** O(n) where n is the number of nodes - we visit each node exactly once
+- **Space Complexity:** O(h) where h is the height of the tree - the recursion stack depth equals the tree height
+- **Edge Case:** If the tree is empty or has no left child, return the root as-is
+
+**1.2 High-level approach:**
+We use recursion to traverse to the leftmost node, which becomes the new root. During the backtracking phase, we reassign pointers to transform the tree structure according to the upside-down pattern.
+
+![Binary tree upside down transformation](https://assets.leetcode.com/static_assets/others/binary-tree-upside-down.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Create a new tree by copying nodes and reassigning pointers iteratively. This requires O(n) extra space.
+- **Optimized Strategy:** Use recursion to transform the tree in-place by reassigning pointers during backtracking. This uses O(h) space for recursion.
+- **Why it's better:** We modify the tree in-place without creating new nodes, making it more memory efficient.
+
+**1.4 Decomposition:**
+1. Recursively traverse to the leftmost node, which will become the new root
+2. During backtracking, reassign the current node's left child's left pointer to the current node's right child
+3. Reassign the current node's left child's right pointer to the current node itself
+4. Set the current node's left and right pointers to None to break old connections
+5. Return the new root (leftmost node) from the deepest recursion
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example tree with nodes [1,2,3,4,5]:
+- Root: 1, left: 2, right: 3
+- Node 2: left: 4, right: 5
+- After transformation, node 4 becomes the new root
+
+**2.2 Start Processing:**
+We begin recursive traversal starting from the root, always going left first.
+
+**2.3 Trace Walkthrough:**
+
+| Node | Has Left? | Action | New Root | Transformations |
+|------|-----------|--------|----------|------------------|
+| 1 | Yes | Go left to 2 | - | - |
+| 2 | Yes | Go left to 4 | - | - |
+| 4 | No | Return 4 | 4 | - |
+| 2 | - | Backtrack | 4 | 4.left = 5, 4.right = 2, 2.left = None, 2.right = None |
+| 1 | - | Backtrack | 4 | 2.left = 3, 2.right = 1, 1.left = None, 1.right = None |
+
+**2.4 Increment and Loop:**
+The recursion naturally handles the traversal. We continue until we reach a node with no left child.
+
+**2.5 Return Result:**
+Return the new root (node 4), which is the leftmost node from the original tree. The tree is now upside down with all pointers correctly reassigned.
+

books/LeetCode_75.md

@@ -0,0 +1,54 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to read n characters from a file using the read4 API, which reads exactly 4 characters at a time. We must handle cases where n might not be a multiple of 4, and we need to stop reading when we've read n characters or reached the end of the file.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= n <= 1000` characters to read
+- **Time Complexity:** O(n) - we read at most n characters, and each read4 call reads up to 4 characters
+- **Space Complexity:** O(1) - we use a fixed-size buffer of 4 characters
+- **Edge Case:** If n is 0, we return 0 without reading. If the file has fewer than n characters, we return the actual number read
+
+**1.2 High-level approach:**
+We repeatedly call read4 to read 4 characters at a time, copying them to the destination buffer until we've read n characters or reached the end of the file. We handle partial reads when n is not a multiple of 4.
+
+![Reading characters in chunks of 4](https://assets.leetcode.com/static_assets/others/read4-api.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Call read4 once for every character needed, which would be inefficient and incorrect since read4 reads 4 characters at a time.
+- **Optimized Strategy:** Call read4 in a loop, reading 4 characters at a time and copying only what we need. This minimizes API calls.
+- **Why it's better:** We make the minimum number of read4 calls needed, reading in optimal chunks of 4.
+
+**1.4 Decomposition:**
+1. Create a temporary buffer of size 4 to store characters from read4
+2. Initialize a counter to track total characters read
+3. Loop while we haven't read n characters yet
+4. Call read4 to get up to 4 characters
+5. Copy the minimum of (characters read, remaining needed) to the destination buffer
+6. Update the total count and continue until done
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `n = 5`, file contains "abcde"
+- Initialize `buf4 = ['', '', '', '']` (temporary buffer)
+- Initialize `total = 0` (characters read so far)
+
+**2.2 Start Reading:**
+We begin the loop to read characters until we've read n characters or reached EOF.
+
+**2.3 Trace Walkthrough:**
+
+| Iteration | total | n - total | read4() returns | buf4 | Copy to buf | total after |
+|-----------|-------|-----------|------------------|------|-------------|--------------|
+| 1 | 0 | 5 | 4 | ['a','b','c','d'] | buf[0:4] = ['a','b','c','d'] | 4 |
+| 2 | 4 | 1 | 1 | ['e','','',''] | buf[4:5] = ['e'] | 5 |
+| End | 5 | 0 | - | - | - | 5 |
+
+**2.4 Increment and Loop:**
+After each read4 call, we update total by the number of characters copied. We continue until total >= n or read4 returns 0 (EOF).
+
+**2.5 Return Result:**
+Return `total = 5`, which is the number of characters successfully read into the buffer. The buffer now contains ['a','b','c','d','e'].
+

books/LeetCode_Top_150.md

@@ -0,0 +1,63 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to read n characters from a file using the read4 API, but the read function may be called multiple times. We must maintain state between calls to handle leftover characters from previous read4 calls that weren't fully consumed.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= n <= 1000` characters per read call
+- **Time Complexity:** O(n) per read call - we process at most n characters per call
+- **Space Complexity:** O(1) amortized - we use a queue that stores at most 4 characters at a time
+- **Edge Case:** If read is called with n=0, return 0. If previous calls left characters in the queue, use them first
+
+**1.2 High-level approach:**
+We maintain a queue to store leftover characters from previous read4 calls. When read is called, we first consume characters from the queue, then call read4 if needed. Any extra characters from read4 are stored in the queue for future calls.
+
+![Maintaining buffer between multiple read calls](https://assets.leetcode.com/static_assets/others/read4-multiple-calls.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Ignore previous state and start fresh each time, which would lose leftover characters and produce incorrect results.
+- **Optimized Strategy:** Use a queue to buffer leftover characters between calls, ensuring we don't lose any data and minimize read4 calls.
+- **Why it's better:** We correctly handle multiple calls by preserving state, and we avoid redundant read4 calls by reusing buffered characters.
+
+**1.4 Decomposition:**
+1. Initialize a queue in the constructor to store leftover characters
+2. When read is called, first check if the queue has characters and use them
+3. If more characters are needed, call read4 to get new characters
+4. Store any extra characters from read4 (beyond what's needed) in the queue
+5. Return the total number of characters read
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: First call `read(buf, 1)`, then `read(buf, 2)`, file contains "abc"
+- Initialize `self.queue = []` in constructor
+- First call needs 1 character, second call needs 2 characters
+
+**2.2 Start Reading:**
+We begin by checking the queue for leftover characters, then call read4 if needed.
+
+**2.3 Trace Walkthrough:**
+
+| Call | n | Queue Before | Action | read4() | Queue After | Return |
+|------|---|--------------|--------|---------|------------|--------|
+| 1 | 1 | [] | Call read4 | 4 chars: ['a','b','c',''] | ['b','c'] | 1 |
+| 2 | 2 | ['b','c'] | Use queue first | - | [] | 2 |
+
+**Detailed first call:**
+- Queue is empty, call read4 → gets ['a','b','c',''] (3 valid chars)
+- Need 1 char, take 'a' from read4 result
+- Store remaining ['b','c'] in queue
+- Return 1
+
+**Detailed second call:**
+- Queue has ['b','c'], take both
+- Need 2 chars, have 2 in queue, perfect
+- Return 2
+
+**2.4 Increment and Loop:**
+We continue processing characters from the queue and calling read4 until we've read n characters or reached EOF.
+
+**2.5 Return Result:**
+Return the total number of characters read (idx). The queue now contains any leftover characters for future read calls.
+

books/Top_100_Liked_Questions.md

@@ -0,0 +1,58 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to find the length of the longest substring that contains at most two distinct characters. This means we can have 0, 1, or 2 different characters in our substring, but not 3 or more.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= s.length <= 10^5`
+- **Time Complexity:** O(n) where n is the length of the string - each character is visited at most twice (once by right pointer, once by left pointer)
+- **Space Complexity:** O(1) - we store at most 2 distinct characters in the hash map
+- **Edge Case:** If the string has fewer than 2 distinct characters, return the entire string length
+
+**1.2 High-level approach:**
+We use a sliding window technique with two pointers. The right pointer expands the window to include new characters, and the left pointer shrinks it when we have more than two distinct characters. We track character frequencies using a hash map.
+
+![Sliding window with two distinct characters](https://assets.leetcode.com/static_assets/others/sliding-window-two-distinct.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Check all possible substrings O(n²) and count distinct characters for each, which is O(n³) total.
+- **Optimized Strategy:** Use sliding window to maintain a valid substring, expanding and contracting as needed. This is O(n) time.
+- **Why it's better:** We avoid checking redundant substrings and process each character at most twice, making it much more efficient.
+
+**1.4 Decomposition:**
+1. Initialize two pointers (left and right) at the start of the string
+2. Use a hash map to count character frequencies in the current window
+3. Expand the window by moving the right pointer and updating counts
+4. When we have more than 2 distinct characters, shrink the window by moving the left pointer
+5. Track the maximum window size throughout the process
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `s = "eceba"`
+- Initialize `left = 0`, `right = 0`, `res = 0`
+- Initialize `char_count = {}` (empty hash map)
+
+**2.2 Start Checking:**
+We begin expanding the window by moving the right pointer.
+
+**2.3 Trace Walkthrough:**
+
+| Step | right | s[right] | char_count | Distinct | Action | left | res |
+|------|-------|-----------|------------|----------|--------|-----|-----|
+| 0 | 0 | 'e' | {'e':1} | 1 | Expand | 0 | 1 |
+| 1 | 1 | 'c' | {'e':1,'c':1} | 2 | Expand | 0 | 2 |
+| 2 | 2 | 'e' | {'e':2,'c':1} | 2 | Expand | 0 | 3 |
+| 3 | 3 | 'b' | {'e':2,'c':1,'b':1} | 3 | Shrink | 1 | 3 |
+| 3a | 3 | 'b' | {'e':1,'c':1,'b':1} | 3 | Shrink | 2 | 3 |
+| 3b | 3 | 'b' | {'e':1,'b':1} | 2 | Expand | 2 | 3 |
+| 4 | 4 | 'a' | {'e':1,'b':1,'a':1} | 3 | Shrink | 3 | 3 |
+| 4a | 4 | 'a' | {'b':1,'a':1} | 2 | Expand | 3 | 3 |
+
+**2.4 Increment and Loop:**
+After processing each character, we increment the right pointer. If we need to shrink, we increment the left pointer until we have at most 2 distinct characters.
+
+**2.5 Return Result:**
+Return `res = 3`, which is the length of the longest substring with at most two distinct characters. In this case, "ece" or "ceb" both have length 3.
+