LeetCode 3010: Divide Array into Subarrays with Min Cost

🚀 Day 5/365 – Recover Binary Search Tree Today I solved an interesting Binary Tree problem: 👉 Recover a Binary Search Tree where exactly two nodes were swapped by mistake — without changing the tree structure. 🧠 Key Insight In a valid Binary Search Tree (BST), an inorder traversal produces a sorted sequence. If two nodes are swapped, this sorted order gets violated. So the strategy is: Perform an inorder traversal Detect the two nodes where the order breaks Swap their values back 🔍 What I Learned ✔️ How inorder traversal helps validate BST properties ✔️ Handling both adjacent and non-adjacent swaps ✔️ Improving problem-solving using pattern recognition ✔️ Importance of maintaining previous node reference ⏱ Complexity Time Complexity: O(n) Space Complexity: O(h) (recursion stack) Can be optimized to O(1) space using Morris Traversal Binary Tree problems always strengthen recursion clarity and tree traversal intuition 🌳 Consistency is the key 🔥 On to the next challenge! #DayXof365 #LeetCode #DataStructures #BinarySearchTree #Java #CodingChallenge #ProblemSolving

Day 65/100 – LeetCode Challenge ✅ Problem: #22 Generate Parentheses Difficulty: Medium Language: Java Approach: Backtracking with State Tracking Time Complexity: O(4ⁿ/√n) — Catalan number Space Complexity: O(n) for recursion stack Key Insight: Valid parentheses require at every prefix: Open brackets can be added anytime (open < n) Close brackets only when close < open (never close more than opened) When string length reaches 2n, add to result. Solution Brief: Recursive backtracking maintaining counts of open and close brackets used. Two branching conditions: Add '(' if open < n Add ')' if close < open Base case: when length = 2n, add valid combination to list. #LeetCode #Day65 #100DaysOfCode #Backtracking #Java #Algorithm #CodingChallenge #ProblemSolving #GenerateParentheses #MediumProblem #Recursion #StringManipulation #DSA

🚀 Day 10/30 – Strengthening String Processing Fundamentals Today’s problem focused on determining whether two strings are anagrams of each other. Instead of sorting both strings (which would take O(n log n) time), I implemented a frequency-count approach using a fixed-size array to track character occurrences. 💡 Approach First, check if the lengths differ — if so, they cannot be anagrams. Use an integer array of size 26 (for lowercase letters). Increment counts for characters in the first string. Decrement counts for characters in the second string. If all values return to zero, the strings are valid anagrams. This approach ensures: ⏱ O(n) time complexity 📦 O(1) space complexity (constant size array) 📊 Performance ✅ All test cases passed ⚡ Efficient runtime 💾 Optimized space usage 📚 Key Takeaway Optimizing from a sorting-based solution to a frequency-count approach highlights the importance of understanding constraints. Sometimes improving complexity from O(n log n) to O(n) is not about writing more code — it's about choosing the right idea. Ten days completed. Small improvements every day compound over time. #Day10 #30DaysOfCode #LeetCode #Java #Algorithms #StringManipulation #ProblemSolving #CodingJourney #SoftwareEngineering #Consistency #TechGrowth

Day 4/100 – LeetCode Challenge Problem Solved: Find First and Last Position of Element in Sorted Array (34) Today I worked on a problem that requires finding the starting and ending index of a target value in a sorted array. If the target is not present, the result should be [-1, -1]. The important constraint is that the solution must run in O(log n) time. Since the array is sorted, this naturally points to Binary Search. Instead of performing a simple search, the idea is to perform two modified binary searches: One to find the first occurrence of the target, and another to find the last occurrence. By carefully adjusting the search boundaries when the target is found, we can narrow down the exact range. This ensures: The algorithm maintains logarithmic time complexity. The solution handles duplicates correctly. Edge cases such as the target not being present are properly addressed. Time Complexity: O(log n) Space Complexity: O(1) Key takeaway: Binary search is not just about finding whether an element exists. With small boundary modifications, it can be adapted to solve range-based problems efficiently. Understanding how to tweak the search condition is more important than memorizing the template. Day 4 completed. Continuing to sharpen problem-solving fundamentals. #100DaysOfLeetCode #BinarySearch #Java #DataStructures #ProblemSolving #Consistency

Headline: Cracking the "Largest Rectangle in Histogram" (LeetCode 84) 🚀 I just cleared this classic Hard problem with a 0ms runtime! The challenge is finding the largest area in a histogram in O(n) time. The secret sauce? A Monotonic Stack. By storing indices of bars in increasing order, we can identify the "boundary" for each height in a single pass. Key takeaway: Choosing the right data structure (like a Stack) can turn an expensive O(n^2) search into a lightning-fast linear solution. 👨💻 #LeetCode #Java #Algorithms #DataStructures #CodingLife

Day 58/100 – LeetCode Challenge ✅ Problem: Longest Balanced Substring II Difficulty: Medium Language: Java Approach: Multiple Pattern Detection + Prefix Difference Mapping Time Complexity: O(n) Space Complexity: O(n) Key Insight: Balanced substrings must have equal counts of characters in three possible patterns: Single character run - consecutive same characters Two characters - equal occurrences of two specific chars Three characters - all three chars appear same number of times Solution Brief: countOne(): Track longest consecutive run of same character. countTwo(): For two chars (like 'a'/'b'), use prefix sum where n1=+1, n2=-1; reset on other chars. countThree(): Track differences (a-b) and (a-c) as state; when same state repeats, balanced substring found. #LeetCode #Day58 #100DaysOfCode #String #HashMap #Java #Algorithm #CodingChallenge #ProblemSolving #LongestBalancedSubstringII #HardProblem #PrefixSum #StateTracking #DSA

Squares of a Sorted Array Solved “Squares of a Sorted Array” using a two-pointer technique instead of brute force. Key idea: Since the array is already sorted, the largest square will always come from either end. Use two pointers (start, end) and fill the result array from back to front. Why this approach? Avoids sorting after squaring Optimized and clean logic Complexity: Time: O(n) Space: O(n) Takeaway: Understanding patterns like two pointers helps convert naive solutions into optimized ones. #DSA #TwoPointers #Java #LeetCode #ProblemSolving

Day 14 of Daily DSA 🚀 Solved LeetCode 153: Find Minimum in Rotated Sorted Array ✅ Approach: Used Binary Search to locate the minimum element in a rotated sorted array. At each step, compared nums[mid] with nums[end] to determine which half is unsorted and contains the minimum. By shrinking the search space intelligently, the minimum element is found efficiently. A great example of how Binary Search adapts to rotated arrays. ⏱ Complexity: • Time: O(log n) • Space: O(1) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 43.66 MB (Beats 87.66%) Binary Search mastery keeps leveling up 💪 #DSA #LeetCode #Java #BinarySearch #ProblemSolving #DailyCoding #Consistency

🚀 Day 17 of #100DaysOfCode Solved 75. Sort Colors on LeetCode 🎨 🧠 Key insight: Although this problem is often solved using the Dutch National Flag algorithm, it was interesting to apply QuickSort and see how a general-purpose sorting algorithm still performs efficiently for constrained inputs. ⚙️ Approach: 🔹Applied QuickSort recursively 🔹Chose the middle element as the pivot 🔹Partitioned the array around the pivot 🔹Continued sorting left and right partitions ⏱️ Time Complexity: Average: O(n log n) 📦 Space Complexity: O(log n) (recursive stack) #100DaysOfCode #LeetCode #DSA #Sorting #QuickSort #Java #ProblemSolving #LearningInPublic #CodingJourney

𝗗𝗮𝘆 𝟯𝟲/𝟭𝟬𝟬 | 𝗠𝗲𝗿𝗴𝗲 𝗧𝘄𝗼 𝗦𝗼𝗿𝘁𝗲𝗱 𝗟𝗶𝘀𝘁𝘀 Day 36 ✅ — Recursion over iteration. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 #𝟮𝟭: Merge Two Sorted Lists (Easy) 𝗪𝗵𝗮𝘁 𝗖𝗹𝗶𝗰𝗸𝗲𝗱: Merge two sorted linked lists. Instead of the iterative dummy node approach, I used 𝗿𝗲𝗰𝘂𝗿𝘀𝗶𝗼𝗻. Compare the heads. Attach the smaller one, then recursively merge the rest. Base case: if one list is empty, return the other. Elegant. Three lines of logic. 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: 👉 Base cases: if l1 is null, return l2 (and vice versa) 👉 Compare l1.val and l2.val 👉 Attach smaller node and recurse with remaining lists Time: O(n + m), Space: O(n + m) for recursion stack 𝗠𝘆 𝗥𝗲𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Seven linked list problems, and recursion just made this one cleaner than iteration. Sometimes the simplest code is the most powerful. 𝗖𝗼𝗱𝗲:🔗 https://lnkd.in/g4f4_B69 𝗗𝗮𝘆 𝟯𝟲/𝟭𝟬𝟬 ✅ | 𝟲𝟰 𝗺𝗼𝗿𝗲 𝘁𝗼 𝗴𝗼! #100DaysOfCode #LeetCode #LinkedList #Recursion #DataStructures #CodingInterview #SoftwareEngineer #Java #Algorithms #Programming