Max Level Sum of Binary Tree with BFS

🚀 #DAY75 of #100DayofDSA Challenge LeetCode Problem #1200 – Minimum Absolute Difference 🧩 Problem Summary Given a list of distinct integers, the goal is to find all element pairs whose absolute difference is the minimum possible and return them in sorted order. 🧠 How It Works First, sort the array to bring close values together Scan once to compute the minimum difference between adjacent elements Scan again to collect all pairs that match this minimum difference This approach leverages the fact that in a sorted array, the smallest difference must occur between neighboring elements. 📘 What I Learned ✔ Why sorting simplifies difference-based problems ✔ How breaking the task into two passes improves clarity ✔ Turning mathematical observations into efficient logic ✔ Writing clean and readable solutions even when performance isn’t maxed 📊 Performance ⏱ Runtime: 95 ms 💾 Memory: 21.57 MB ✅ 38 / 38 testcases passed 📌 Small optimizations, big clarity — consistency is the real win. #LeetCode #DSA #Algorithms #ProblemSolving #Python #CodingPractice #DataStructures #TechJourney #100DaysOfDSA #LearningByDoing #Consistency #InterviewPrep #CompetitiveProgramming

🗓 Day 64 / 100 – #100DaysOfLeetCode 📌 Problem 1339: Maximum Product of Splitted Binary Tree Today’s problem combined tree traversal with optimization logic. The task was to split a binary tree into two subtrees by removing exactly one edge, such that the product of the sums of the two resulting subtrees is maximized. 🧠 My Approach: First, computed the total sum of all nodes in the tree. Used a post-order DFS traversal to calculate the sum of each subtree. For every subtree: Considered it as one part after the split. The other part would have sum: total_sum − subtree_sum Calculated the product of these two values. Tracked the maximum product across all possible splits. Returned the result modulo 109+710^9 + 7109+7, as required. Post-order traversal works perfectly here because subtree sums must be known before evaluating the split. 💡 Key Learning: This problem reinforced: ✔ how post-order DFS is ideal for subtree-based calculations ✔ combining traversal with optimization criteria ✔ thinking globally (total sum) while evaluating local decisions (each split) A great example of how tree problems often require two passes: one for data collection and one for optimization. Another strong tree-based DP-style problem completed 🌳🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #BinaryTree #DFS #TreeDP #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🗓 Day 66 / 100 – #100DaysOfLeetCode 📌 Problem 865: Smallest Subtree with All the Deepest Nodes Today’s problem focused on binary tree depth analysis. The goal was to find the smallest subtree that contains all the deepest nodes in the tree. 🧠 My Approach: Used Depth-First Search (DFS) to compute information bottom-up. For each node, tracked: the maximum depth reachable from that node, and the candidate subtree root that contains all deepest nodes. Compared depths of left and right subtrees: If both sides have the same depth → the current node is the answer. Otherwise, propagated the deeper side upward. Returned the node that satisfies the condition for all deepest nodes. This approach cleanly combines depth calculation with subtree selection in a single traversal. 💡 Key Learning: This problem reinforced: ✔ how returning multiple values from DFS simplifies logic ✔ thinking bottom-up for tree optimization problems ✔ identifying the exact node where depths converge Tree problems often become elegant once the right recursive structure is identified 🌳🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #BinaryTree #DFS #TreeTraversal #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🚀 #DAY74 LeetCode Problem #1200 – Minimum Absolute Difference 🧩 Problem Summary Given a list of distinct integers, the goal is to find all element pairs whose absolute difference is the minimum possible and return them in sorted order. 🧠 How It Works First, sort the array to bring close values together Scan once to compute the minimum difference between adjacent elements Scan again to collect all pairs that match this minimum difference This approach leverages the fact that in a sorted array, the smallest difference must occur between neighboring elements. 📘 What I Learned ✔ Why sorting simplifies difference-based problems ✔ How breaking the task into two passes improves clarity ✔ Turning mathematical observations into efficient logic ✔ Writing clean and readable solutions even when performance isn’t maxed 📊 Performance ⏱ Runtime: 95 ms 💾 Memory: 21.57 MB ✅ 38 / 38 testcases passed 📌 Small optimizations, big clarity — consistency is the real win. #LeetCode #DSA #Algorithms #ProblemSolving #Python #CodingPractice #DataStructures #TechJourney #100DaysOfDSA #LearningByDoing #Consistency #InterviewPrep #CompetitiveProgramming

🚀 LeetCode Daily Challenge – Day 9 Problem #865: Smallest Subtree with All the Deepest Nodes (Medium) Another solid tree + DFS problem that really tests how well you understand recursion and depth tracking. 🧭 How I Approached the Question: The key was realizing that I don’t just need the depth of each subtree — I also need to know which node represents the smallest subtree containing all deepest nodes. So instead of a normal DFS, I designed a recursive function that returns two things: the height of the subtree the candidate node that could be the answer 🧠 Core Insight: For each node: Recursively compute (height, node) from the left and right subtrees Compare their heights: If left height > right height → deepest nodes are on the left If right height > left height → deepest nodes are on the right If equal → current node becomes the smallest subtree containing all deepest nodes This bottom-up approach ensures that: ✔️ Depth is calculated correctly ✔️ The smallest valid subtree is chosen automatically 🛠️ Why This Works: The deepest nodes define the maximum depth. The lowest common ancestor of all deepest nodes is exactly what the problem asks for. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) This problem was a great reminder that: 👉 Sometimes returning more information from recursion makes the solution much cleaner. 📌 Tree problems get easier once you stop thinking top-down and start thinking bottom-up. #LeetCode #DailyCoding #BinaryTree #DFS #Recursion #ProblemSolving #DSA #Python #CodingJourney

❄️ takeUforward — Day 25 ✅ Search Insert Position | Arrays | LeetCode Today I solved the Search Insert Position problem, which focuses on understanding array traversal and positioning logic in a sorted array. 🧩 Problem Statement Given a sorted array nums and a target value target, return the index if the target is found. If not, return the index where it would be inserted in order. ⚡ Approach — Linear Scan 💡 Idea • Traverse the array from left to right. • As soon as an element is greater than or equal to the target, return its index. • If the target is larger than all elements, insert it at the end. . Complexity • Time: O(n) • Space: O(1) 📌 Key Learning Even simple problems strengthen fundamentals. This problem highlights how clear conditions and early returns can make solutions efficient and readable. 🚀 Day 25 completed — reinforcing array fundamentals and edge-case handling. #DSA #DataStructures #Algorithms #Python #LeetCode #CodingJourney #ProblemSolving #InterviewPreparation #LearnInPublic #Consistency

❄️ takeUforward — Day 18 ✅ Two Sum | Hashing | LeetCode (Easy) Today I solved the classic Two Sum problem on LeetCode using an optimal hashing approach, focusing on reducing time complexity from brute force to linear time. Problem Statement Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target. ✔ Exactly one solution exists ✔ Same element cannot be used twice Approach (Hash Map / Dictionary) Idea • Traverse the array once. • For each element, calculate remaining = target - nums[i]. • If remaining already exists in the hash map → solution found. • Otherwise, store the current number with its index in the map. This avoids nested loops and gives an optimal solution. Example Input: nums = [2, 7, 11, 15], target = 9 Output: [0, 1] ⏱ Complexity Analysis • Time Complexity: O(n) • Space Complexity: O(n) 📌 Key Learning (Day 18) • Hashing helps convert quadratic problems into linear ones. • Storing elements before moving ahead avoids reuse issues. • Understanding lookup trade-offs is crucial in array problems. #DSA #Arrays #Hashing #TwoSum #LeetCode #Python #ProblemSolving #LogicBuilding #CodingJourney #RestartDSA #100DaysOfCode #DailyCoding

🚀 Day 77 of #100DaysOfCode — Find the Second Largest Digit Hey everyone! 👋 Today's challenge is "Second Largest Digit in a String" — a great problem for practicing digit extraction, comparison logic, and edge-case handling. We’ll search through a mixed string of letters and numbers to find the second largest digit, or return -1 if it doesn’t exist. 👨💻 What l practiced today: ✅ String Traversal: Looping through each character and identifying digits. ✅ Digit Comparison: Keeping track of the largest and second-largest digits efficiently. ✅ Edge Cases: Handling cases with no digits, only one digit, or duplicate digits. 📌 Today’s Task: ✔ Given an alphanumeric string s. ✔ Return the second largest numerical digit that appears in s. ✔ Return -1 if it doesn’t exist. Example: Input: s = "dfa12321afd" Digits: [1, 2, 3] Second largest: 2 → Output: 2 🧠 Key Insight: You can solve this by scanning the string once, tracking the largest and second largest digits. Remember to skip duplicates and handle cases where all digits are the same. #100DaysOfCode #Day77 #Python #LeetCode #DSA #StringManipulation #DigitExtraction #EdgeCases #AlgorithmPractice #LogicBuilding

DSA Daily — Two Pointer Pattern LeetCode 167: Two Sum II — Input Array Is Sorted Day 3 of consistent problem solving I didn’t start with brute force this time — I went straight for the Two Pointer technique, and it worked cleanly. 🔹 Why Two Pointers was the obvious choice here Before writing any code, a few strong signals stood out: The array is already sorted We need two distinct indices Constant extra space is required These constraints immediately rule out: Hash maps (extra space) Nested loops (inefficient) 👉 A sorted array + pair-based condition = Two Pointers. 🔹 Two Pointer Approach (Optimal) Idea: Place one pointer at the start (left) Place another at the end (right) Adjust pointers based on the sum Sorted order guarantees that these moves are meaningful This avoids checking all pairs while still exploring the full search space. Complexity: Time: O(n) Space: O(1) 🧠 What I’m understanding better about Two Pointers Sorted arrays allow you to make directional decisions instead of brute-force checks Pointer movement is driven by problem constraints, not trial and error When a problem asks for constant space and the input is sorted, Two Pointers should be one of the first ideas Continuing my DSA Daily series focused on mastering patterns through reasoning, not memorization. #DSADaily #TwoPointers #LeetCode #ProblemSolving #CodingJourney #Python

Day 62 of #100DaysOfLeetCode Today’s problem focused on tree traversal and level-wise aggregation, a foundational concept that appears frequently in interviews and real-world systems. 🌲 Maximum Level Sum of a Binary Tree (LeetCode 1161) Given a binary tree, the task was to determine which level has the maximum sum of node values — and return the smallest level index if multiple levels tie. 🧠 My Approach Used Breadth-First Search (BFS) to traverse the tree level by level Maintained: Current level number Sum of values at each level Updated the answer whenever a new maximum level sum was found BFS makes this problem clean, intuitive, and efficient. 💡 What I Learned BFS is ideal for level-based problems in trees Tracking state (level, sum, max) is often more important than recursion Simple traversal patterns solve many “medium” tree problems 📊 Complexity Analysis Time Complexity: O(n) Space Complexity: O(n) (queue for BFS) ✅ Day 62 Summary A solid reminder that mastering tree fundamentals pays off long-term. Clear logic, predictable traversal, reliable results. Day 62 complete. Momentum intact. On to Day 63. 🚀 #100DaysOfLeetCode #Day62 #LeetCode #BinaryTree #BFS #TreeTraversal #Python #DSA #ProblemSolving #CodingJourney #Consistency #AdityaCodes