Solving LeetCode's Restore The Array with Dynamic Programming

Day 84 of My DSA Journey Today’s problem: Counting Bits Given a number n, the task is to return an array where each index i contains the number of 1’s in the binary representation of i. 🔍 Example: Input: n = 5 Output: [0, 1, 1, 2, 1, 2] 💡 Key Insight: Instead of counting bits every time, we reuse previous results: i >> 1 → removes last bit i & 1 → checks if last bit is 1 So, 👉 ans[i] = ans[i >> 1] + (i & 1) ⚡ This reduces time complexity to O(n) (single pass!) 📈 What I learned today: Dynamic Programming can simplify repeated computations Bit manipulation makes problems faster and cleaner Small patterns can lead to big optimizations #Day84 #DSA #Java #CodingJourney #100DaysOfCode

“Most people try to overcomplicate this one… but the simplest approach wins.” Day 69 — LeetCode Progress Problem: Height Checker Required: Given an array of student heights, return the number of indices where the heights are not in the expected non-decreasing order. Idea: If we sort the array, we get the expected order. Now just compare the original array with the sorted version — mismatches are the answer. Approach: Create a copy of the original array Sort the copied array Traverse both arrays: Compare elements at each index If they differ → increment count Return the count Time Complexity: O(n log n) Space Complexity: O(n) #LeetCode #DSA #Java #Arrays #Sorting #ProblemSolving #CodingJourney

🚀 DSA Journey: 15/75 Completed 📌 Problem: Maximum Number of Vowels in a Substring of Given Length Today’s problem was a great example of the Sliding Window technique. 🔍 Key Idea: Instead of checking every substring (which is inefficient), we maintain a window of size k and: Add the next character to the window Remove the previous character Track the maximum number of vowels 💡 This reduces time complexity to O(n) — much better than brute force! 🧠 What I Learned: How to efficiently manage a fixed-size window Importance of updating values while sliding Avoiding unnecessary recalculations 🔥 Progress: 15 / 75 problems done — consistency is the real key! #DSA #CodingJourney #Java #LeetCode #100DaysOfCode #ProblemSolving

🔥 𝗗𝗮𝘆 𝟵𝟴/𝟭𝟬𝟬 — 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 𝟳𝟬. 𝗖𝗹𝗶𝗺𝗯𝗶𝗻𝗴 𝗦𝘁𝗮𝗶𝗿𝘀 | 🟢 Easy | Java The gateway problem to Dynamic Programming — and one of the most iconic problems in DSA. 🪜 🔍 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 You can climb 1 or 2 steps at a time. How many distinct ways can you reach the top of n stairs? 💡 𝗧𝗵𝗲 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 To reach step i, you either came from step i-1 (1 step) or step i-2 (2 steps). So ways(i) = ways(i-1) + ways(i-2) Sound familiar? It's literally the Fibonacci sequence. 🐇 ⚡ 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 — 𝗕𝗼𝘁𝘁𝗼𝗺-𝗨𝗽 𝗗𝗣 ✅ Base cases: dp[1] = 1, dp[2] = 2 ✅ Fill dp[i] = dp[i-1] + dp[i-2] for i from 3 to n ✅ Return dp[n] No recursion. No stack overflow. No repeated subproblems. Just a clean bottom-up table. 🧠 📊 𝗖𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆 ⏱ Time: O(n) — single pass 📦 Space: O(n) — can be further optimised to O(1) with just two variables This problem teaches the most important DP lesson: identify overlapping subproblems, store results, build up from the base. Every hard DP problem starts with this same thinking. 𝗔𝗻𝗱 𝘆𝗲𝘀 — 𝗷𝘂𝘀𝘁 𝗹𝗶𝗸𝗲 𝘁𝗵𝗲𝘀𝗲 𝘀𝘁𝗮𝗶𝗿𝘀, 𝘁𝗵𝗶𝘀 𝗰𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 𝘄𝗮𝘀 𝗰𝗹𝗶𝗺𝗯𝗲𝗱 𝗼𝗻𝗲 𝗱𝗮𝘆 𝗮𝘁 𝗮 𝘁𝗶𝗺𝗲. 🏔️ 📂 𝗙𝘂𝗹𝗹 𝘀𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗼𝗻 𝗚𝗶𝘁𝗛𝘂𝗯: https://lnkd.in/gS3DX_YW 𝗝𝘂𝘀𝘁 𝟮 𝗺𝗼𝗿𝗲 𝗱𝗮𝘆𝘀. 𝗧𝗵𝗲 𝘀𝘂𝗺𝗺𝗶𝘁 𝗮𝘄𝗮𝗶𝘁𝘀! 🏁 #LeetCode #Day98of100 #100DaysOfCode #Java #DSA #DynamicProgramming #Fibonacci #CodingChallenge #Programming

Day 40 #SDE recursion, backtracking, and dynamic programming patterns. Solved: • Subset Sum • Palindrome Partitioning Key Learning: • “Subset Sum” strengthens understanding of **recursion + DP (0/1 choice pattern)**, where we decide to include or exclude elements to reach a target. • “Palindrome Partitioning” is a classic **backtracking problem**, where we partition a string such that every substring is a palindrome — combining recursion with validation checks. #LeetCode #DSA #DynamicProgramming #Backtracking #Algorithms #Java #SoftwareEngineering

Day 4/30 — DSA Challenge 🚀 Problem: Path Sum Topic: Tree + Recursion Difficulty: Easy Approach: Used DFS to traverse all root-to-leaf paths Kept a running sum while traversing At leaf node → checked if sum equals target Mistake / Challenge: Initially confused about when to check the sum Tried checking at every node instead of only at leaf nodes Fix: Checked condition only when reaching a leaf node Simplified recursion by passing current sum Key Learning: In tree problems, clearly identify the base condition (leaf node here) Avoid unnecessary checks at intermediate nodes Time Taken: 30 minutes Consistency check ✅ See you on Day 5. GitHub Repo: https://lnkd.in/gHW9vKUf #DSA #LeetCode #Java #Trees #Recursion #LearningInPublic

Day 41 #SDE stack-based validation and dynamic programming on strings. Solved: • Bracket Challenge • Word Break Key Learning: • “Bracket Challenge” reinforces the use of a stack to validate balanced parentheses and handle nested structures efficiently. • “Word Break” revisited the DP + memoization approach, where we check valid segmentations of a string using a dictionary. #LeetCode #DSA #Stack #DynamicProgramming #Algorithms #Java #SoftwareEngineering

Day 68 of #100DaysOfLeetCode 💻✅ Solved #977. Squares of a Sorted Array problem in Java. Approach: • Traversed the array and squared each element • Used Arrays.sort() to sort the squared values • Returned the sorted array as the result Performance: ✓ Runtime: 10 ms (Beats 37.38% submissions) ✓ Memory: 47.98 MB (Beats 18.78% submissions) Key Learning: ✓ Practiced array transformation and sorting ✓ Learned how squaring affects order in sorted arrays ✓ Understood the importance of optimizing from O(n log n) to O(n) using two pointers Learning one problem every single day 🚀 #Java #LeetCode #DSA #Arrays #Sorting #ProblemSolving #CodingJourney #100DaysOfCode

Another step forward in my DSA journey 🚀 After going through the basics, I’ve now started Arrays — and today was all about understanding how they actually work under the hood. 💡 Key takeaway: Arrays are stored in the heap, but each array itself is allocated as a continuous block of memory — making indexing fast and efficient. Also explored: • Why arrays are needed • Internal working & memory representation • Dynamic memory allocation • null & default values in Java • for-each loop & toString() • Arrays of objects • Passing arrays in functions Small concept, big clarity. This is where real problem-solving starts. #DSA #Java #LearningInPublic #Consistency #CodingJourney