Binary Tree Maximum Path Sum

Author: dksifoua

README.md

@@ -1,33 +1,33 @@
 # [Two Sum](https://leetcode.com/problems/two-sum/)
 
-The "Two Sum" problem on LeetCode is a fundamental challenge in array manipulation and hash table usage. Let's explore 
+The "Two Sum" problem on LeetCode is a fundamental challenge in array manipulation and hash table usage. Let's explore
 the optimal solution:
 
 ## Intuition
 
-The primary intuition behind solving the Two Sum problem efficiently is recognizing that each number needs a specific 
-**"partner"** number to reach the target sum. This understanding shifts the focus from searching for a number to 
-identifying its necessary partner. The key insight is to store and quickly look up these partner numbers as we 
+The primary intuition behind solving the Two Sum problem efficiently is recognizing that each number needs a specific
+**"partner"** number to reach the target sum. This understanding shifts the focus from searching for a number to
+identifying its necessary partner. The key insight is to store and quickly look up these partner numbers as we
 iterate through the array.
 
 ## Approach
 
-1. **Hash Table Usage:** The optimal approach involves using a hash table to store numbers from the array along with 
-their indices. The hash table allows for constant-time lookups, which is crucial for efficiency.
+1. **Hash Table Usage:** The optimal approach involves using a hash table to store numbers from the array along with
+   their indices. The hash table allows for constant-time lookups, which is crucial for efficiency.
 
-2. **Single Pass Iteration:** As we iterate through the array, we compute the complement (or partner) for each number 
-(i.e., target - currentNumber). We then check if this complement is already in the hash table.
+2. **Single Pass Iteration:** As we iterate through the array, we compute the complement (or partner) for each number
+   (i.e., target - currentNumber). We then check if this complement is already in the hash table.
 
-3. **Early Return:** If the complement is found, it means a pair that sums up to the target has been identified, and we 
-can immediately return their indices. If not, we store the current number and its index in the hash table for future 
-reference.
+3. **Early Return:** If the complement is found, it means a pair that sums up to the target has been identified, and we
+   can immediately return their indices. If not, we store the current number and its index in the hash table for future
+   reference.
 
 ## Complexity
 
-- **Time Complexity: O(N)**, where N is the number of elements in the array. This is because each element is processed 
-exactly once, and hash table operations like insertion and lookup are O(1).
-- **Space Complexity: O(N)** in the worst-case scenario, which occurs when no matching pair is found until the end of 
-the array, necessitating storing all elements in the hash table.
+- **Time Complexity: O(N)**, where N is the number of elements in the array. This is because each element is processed
+  exactly once, and hash table operations like insertion and lookup are O(1).
+- **Space Complexity: O(N)** in the worst-case scenario, which occurs when no matching pair is found until the end of
+  the array, necessitating storing all elements in the hash table.
 
 ## Code
 

docs/0001-Two-Sum.md

@@ -2,27 +2,27 @@
 
 ## Intuition
 
-The “Container With Most Water” problem involves finding two lines (out of a given array of heights) that together with 
-the x-axis form a container, such that the container holds the maximum amount of water. The key observation is that the 
-amount of water held by the container is determined by the shorter of the two lines and the distance between them. 
+The “Container With Most Water” problem involves finding two lines (out of a given array of heights) that together with
+the x-axis form a container, such that the container holds the maximum amount of water. The key observation is that the
+amount of water held by the container is determined by the shorter of the two lines and the distance between them.
 Therefore, to maximize the water held, we should consider both the height of the lines and the distance between them.
 
 ## Approach
 
-1.	**Initialize Two Pointers:** Start with two pointers, one at the beginning `leftIndex` and one at the end
-`rightIndex` of the array.
-2.	**Calculate the Area:** In each iteration, calculate the area formed by the lines at the left and right pointers and
-the distance between them.
-3.	**Update Maximum Area:** Keep track of the maximum area encountered so far.
-4.	**Move the Pointers:** Move the pointer that points to the shorter line inward. This is because moving the taller 
-line inward will not increase the height of the water (since it is constrained by the shorter line), and moving the 
-shorter line inward might find a taller line that increases the water capacity.
-5.	**Repeat:** Continue this process until the two pointers meet.
+1. **Initialize Two Pointers:** Start with two pointers, one at the beginning `leftIndex` and one at the end
+   `rightIndex` of the array.
+2. **Calculate the Area:** In each iteration, calculate the area formed by the lines at the left and right pointers and
+   the distance between them.
+3. **Update Maximum Area:** Keep track of the maximum area encountered so far.
+4. **Move the Pointers:** Move the pointer that points to the shorter line inward. This is because moving the taller
+   line inward will not increase the height of the water (since it is constrained by the shorter line), and moving the
+   shorter line inward might find a taller line that increases the water capacity.
+5. **Repeat:** Continue this process until the two pointers meet.
 
 ## Complexity
 
-- **Time Complexity: O(N)**, where `N` is the number of elements in the input array. This is because each element is 
-considered at most once by the two pointers, which move towards each other.
+- **Time Complexity: O(N)**, where `N` is the number of elements in the input array. This is because each element is
+  considered at most once by the two pointers, which move towards each other.
 - **Space Complexity: O(1)**, as the algorithm uses a constant amount of extra space regardless of the input size.
 
 ## Code

docs/0011-Container-With-Most-Water.md

@@ -2,7 +2,9 @@
 
 ## Intuition
 
-The problem requires us to find all unique triplets in an array that sum up to zero. Given the constraints and the need to avoid duplicates, a sorted array and a two-pointer approach are suitable. Sorting helps in easily skipping duplicates and efficiently using two pointers to find pairs that sum up to a target.
+The problem requires us to find all unique triplets in an array that sum up to zero. Given the constraints and the need
+to avoid duplicates, a sorted array and a two-pointer approach are suitable. Sorting helps in easily skipping duplicates
+and efficiently using two pointers to find pairs that sum up to a target.
 
 ## Approach
 
@@ -11,16 +13,18 @@ The problem requires us to find all unique triplets in an array that sum up to z
     - Use a loop to fix one element of the triplet. This element will be the current element in the loop.
     - Skip duplicate elements to ensure the uniqueness of the triplets.
 3. **Two-Pointer Technique:**
-    - For each fixed element, use two pointers (`left` and `right`) to find pairs that sum up to the negative of the fixed element.
+    - For each fixed element, use two pointers (`left` and `right`) to find pairs that sum up to the negative of the
+      fixed element.
     - Adjust the pointers based on the sum of the triplet:
-      - If the sum is less than zero, move the left pointer to the right to increase the sum.
-      - If the sum is greater than zero, move the right pointer to the left to decrease the sum.
-      - If the sum is zero, add the triplet to the result list and move both pointers, skipping duplicates.
+        - If the sum is less than zero, move the left pointer to the right to increase the sum.
+        - If the sum is greater than zero, move the right pointer to the left to decrease the sum.
+        - If the sum is zero, add the triplet to the result list and move both pointers, skipping duplicates.
 4. **Return the Result:** After processing all elements, return the list of unique triplets.
 
 ## Complexity
 
-- **Time Complexity: `O(N^2)`**, where `N` is the number of elements in the array. Sorting the array takes `O(NlogN)`, and the two-pointer technique takes `O(N^2)` in the worst case.
+- **Time Complexity: `O(N^2)`**, where `N` is the number of elements in the array. Sorting the array takes `O(NlogN)`,
+  and the two-pointer technique takes `O(N^2)` in the worst case.
 - **Space Complexity: `O(1)` or `O(N)`** depending on the implementation of sorting the input.
 
 ## Code

docs/0015-Three-Sum.md

@@ -2,9 +2,9 @@
 
 ## Intuition
 
-Generating all combinations of well-formed parentheses involves understanding the balance between open and close 
-parentheses. A well-formed parentheses sequence must ensure that at no point do the close parentheses exceed the open 
-ones, and by the end, the counts of open and close parentheses must be equal. This ensures that every opening 
+Generating all combinations of well-formed parentheses involves understanding the balance between open and close
+parentheses. A well-formed parentheses sequence must ensure that at no point do the close parentheses exceed the open
+ones, and by the end, the counts of open and close parentheses must be equal. This ensures that every opening
 parenthesis has a corresponding closing one, forming valid sequences.
 
 ## Approach
@@ -14,20 +14,21 @@ of parentheses and ensures we only consider valid sequences. Here’s a step-by-
 
 1. **Initialization:** We start with an empty string and zero counts for both open and close parentheses.
 2. **Backtracking Function:** The backtrack function recursively builds the parentheses sequences.
-    - *Base Case:* When the counts of both open and close parentheses reach `N`, a valid sequence is formed, and we add 
-    it to the result list.
-    - *Add Open Parenthesis:* If the count of open parentheses is less than `N`, we can add an open parenthesis and 
-   recursively call the function.
-    - *Add Close Parenthesis:* If the count of close parentheses is less than the count of open parentheses, we can add 
-   a close parenthesis and recursively call the function.
+    - *Base Case:* When the counts of both open and close parentheses reach `N`, a valid sequence is formed, and we add
+      it to the result list.
+    - *Add Open Parenthesis:* If the count of open parentheses is less than `N`, we can add an open parenthesis and
+      recursively call the function.
+    - *Add Close Parenthesis:* If the count of close parentheses is less than the count of open parentheses, we can add
+      a close parenthesis and recursively call the function.
 3. **Recursion:** This process continues until all valid sequences are generated and stored in the result list.
 
 ## Complexity
 
-- **Time Complexity:** The time complexity is `O(4^N / \sqrt{N})`. This is derived from the fact that the number of 
-valid sequences is given by the [nth Catalan number](https://en.wikipedia.org/wiki/Catalan_number), which grows exponentially.
-- **Space Complexity:** The space complexity is `O(4^N / \sqrt{N})` for the result list storing all sequences. 
-Additionally, the recursion stack depth is `O(N)`, making the auxiliary space complexity also `O(N)`.
+- **Time Complexity:** The time complexity is `O(4^N / \sqrt{N})`. This is derived from the fact that the number of
+  valid sequences is given by the [nth Catalan number](https://en.wikipedia.org/wiki/Catalan_number), which grows
+  exponentially.
+- **Space Complexity:** The space complexity is `O(4^N / \sqrt{N})` for the result list storing all sequences.
+  Additionally, the recursion stack depth is `O(N)`, making the auxiliary space complexity also `O(N)`.
 
 ## Code
 

docs/0022-Generate-Parentheses.md

@@ -2,27 +2,27 @@
 
 ## Intuition
 
-The problem requires finding a target value in a rotated sorted array. The key challenge is to achieve this in 
-`O(log N)` time complexity, which suggests using a binary search approach. The main insight is that even though the 
-array is rotated, at least one half of the array (either left or right of the middle) will always be sorted. This 
+The problem requires finding a target value in a rotated sorted array. The key challenge is to achieve this in
+`O(log N)` time complexity, which suggests using a binary search approach. The main insight is that even though the
+array is rotated, at least one half of the array (either left or right of the middle) will always be sorted. This
 property can be exploited to decide which half to discard in each step of the binary search.
 
 ## Approach
 
-1. **Initialize Pointers:** Start with two pointers, `leftIndex` at the beginning of the array and `rightIndex` at the 
-end.
+1. **Initialize Pointers:** Start with two pointers, `leftIndex` at the beginning of the array and `rightIndex` at the
+   end.
 2. **Binary Search Loop:** Use a while loop that continues as long as `leftIndex` is less than or equal to `rightIndex`.
 3. **Find Middle:** Calculate the middle index, `middleIndex`, as the average of `leftIndex` and `rightIndex`.
 4. **Check Middle:** If the element at `middleIndex` is the target, return `middleIndex`.
 5. **Determine Sorted Half:**
     - **Left Half Sorted:** If `nums[leftIndex] <= nums[middleIndex]`, then the left half is sorted. Check if the target
-    lies within this sorted half (`nums[leftIndex] <= target < nums[middleIndex]`).
-      - If yes, move `rightIndex` to `middleIndex - 1`.
-      - Otherwise, move `leftIndex` to `middleIndex + 1`.
-    - **Right Half Sorted:** Otherwise, the right half must be sorted. Check if the target lies within this sorted half 
-    (`nums[middleIndex] < target <= nums[rightIndex]`).
-      - If yes, move `leftIndex` to `middleIndex + 1`.
-      - Otherwise, move `rightIndex` to `middleIndex - 1`.
+      lies within this sorted half (`nums[leftIndex] <= target < nums[middleIndex]`).
+        - If yes, move `rightIndex` to `middleIndex - 1`.
+        - Otherwise, move `leftIndex` to `middleIndex + 1`.
+    - **Right Half Sorted:** Otherwise, the right half must be sorted. Check if the target lies within this sorted half
+      (`nums[middleIndex] < target <= nums[rightIndex]`).
+        - If yes, move `leftIndex` to `middleIndex + 1`.
+        - Otherwise, move `rightIndex` to `middleIndex - 1`.
 6. **Return -1:** If the loop ends without finding the target, return -1.
 
 ## Complexity
@@ -36,6 +36,6 @@ end.
 
 ## Summary
 
-This solution effectively uses a modified binary search to find the target in a rotated sorted array. By identifying 
-which half of the array is sorted at each step, We decide whether to search the left or right half, ensuring that the 
+This solution effectively uses a modified binary search to find the target in a rotated sorted array. By identifying
+which half of the array is sorted at each step, We decide whether to search the left or right half, ensuring that the
 algorithm runs in logarithmic time. This approach is efficient and well-suited for the constraints given in the problem.

docs/0033-Search-In-Rotated-Sorted-Array.md

@@ -2,40 +2,42 @@
 
 ## Intuition
 
-The core idea is to ensure that each number from `1` to `9` appears only once in each row, each column, and each of the 
-nine 3x3 sub-boxes of the Sudoku board. By keeping track of the numbers we have seen so far in each row, column, and 
+The core idea is to ensure that each number from `1` to `9` appears only once in each row, each column, and each of the
+nine 3x3 sub-boxes of the Sudoku board. By keeping track of the numbers we have seen so far in each row, column, and
 box, we can efficiently determine if the Sudoku board is valid or not.
 
 ## Approach
 
 **Initialization:** We use three hash maps to keep track of the characters we encounter:
-  - `rows` to track characters for each row.
-  - `cols` to track characters for each column.
-  - `boxes` to track characters for each 3x3 sub-box. 
-  - Each of these maps contains sets, which will store the characters seen so far.
+
+- `rows` to track characters for each row.
+- `cols` to track characters for each column.
+- `boxes` to track characters for each 3x3 sub-box.
+- Each of these maps contains sets, which will store the characters seen so far.
 
 **Filling the Maps:**
-  - We iterate over each cell in the board using nested loops.
-  - For each cell, if the character is not `.`, we do the following:
+
+- We iterate over each cell in the board using nested loops.
+- For each cell, if the character is not `.`, we do the following:
     - Calculate the corresponding 3x3 box index using integer division (`rb = i / 3` and `cb = j / 3`).
     - Check if the character already exists in the respective row, column, or box set.
     - If it does, return `false` as it violates the Sudoku rule.
     - If it does not, add the character to the respective sets.
 
-**Final Check:** If we complete the iteration without finding any duplicates, we return `true`, indicating the board is 
+**Final Check:** If we complete the iteration without finding any duplicates, we return `true`, indicating the board is
 valid.
 
 ## Complexity
 
 - **Time Complexity: O(1)**
-  - We always iterate over a fixed 9x9 board, making the iteration part of the solution constant in terms of time 
-complexity. Each cell is visited once.
-  - The operations of checking and adding elements to the sets are average `O(1)` operations.
+    - We always iterate over a fixed 9x9 board, making the iteration part of the solution constant in terms of time
+      complexity. Each cell is visited once.
+    - The operations of checking and adding elements to the sets are average `O(1)` operations.
 - **Space Complexity: O(1)**
-  - Although we use additional data structures (maps and sets), their sizes are fixed and proportional to the size of 
-the board, which is constant (81 cells).
-  - Each map (rows, cols, boxes) holds at most 9 sets, and each set can hold up to 9 elements, making the extra space 
-used constant.
+    - Although we use additional data structures (maps and sets), their sizes are fixed and proportional to the size of
+      the board, which is constant (81 cells).
+    - Each map (rows, cols, boxes) holds at most 9 sets, and each set can hold up to 9 elements, making the extra space
+      used constant.
 
 ## Code