House Robber Problem Solution in Java with Dynamic Programming

Day 56/100 – LeetCode Challenge Problem: Minimum Cost For Tickets Today I solved the “Minimum Cost For Tickets” problem, which is a dynamic programming problem centered around making optimal decisions over a timeline. The goal is to minimize the total cost of travel tickets by choosing between 1-day, 7-day, and 30-day passes. Instead of making decisions greedily, I approached this by building a DP array where each day represents the minimum cost required up to that point. For each travel day, I considered three possibilities: buying a 1-day pass, a 7-day pass, or a 30-day pass. I then chose the minimum among these options by looking back into previously computed states. For non-travel days, I simply carried forward the previous cost, avoiding unnecessary purchases. This approach ensures that every decision is backed by previously computed optimal results, making the solution both efficient and reliable. The solution runs in O(n) time with O(n) space complexity. This problem reinforced how dynamic programming helps in breaking down decisions over time and choosing the most cost-effective path by evaluating all possible options. Fifty-six days in. The focus is now on making smarter decisions through structured thinking. #100DaysOfLeetCode #Java #DSA #DynamicProgramming #ProblemSolving #Consistency

I recently encountered an ambiguous mapping error while working on a REST API. The stack trace was overwhelming, but the message was straightforward : I had two different methods competing for the same URL and HTTP verb. The issue happened because I had two methods, createEmployee and createNewEmployee, both annotated with @PostMapping, along with @RequestMapping on the controller class. Spring couldn't determine which method to use to handle the request. To resolve this, it's essential to keep the endpoints unique or utilize different HTTP methods to maintain organization. Happy coding! #Java #SpringBoot #Programming #SoftwareEngineering #Debugging

🚀 Day 559 of #750DaysOfCode 🚀 🔍 LeetCode 3741: Minimum Distance Between Three Equal Elements II Today’s problem was an extension of yesterday’s question — but with larger constraints (n up to 1e5), making efficiency crucial ⚡ 💡 Problem Recap: Find three indices (i, j, k) such that: nums[i] == nums[j] == nums[k] Distance = |i - j| + |j - k| + |k - i| is minimized ✨ Approach I Used (Clean & Intuitive): ✔ Stored indices of each number using a HashMap ✔ For each number: If it appears ≥ 3 times Check consecutive triplets of indices ✔ Compute distance using: 👉 |i - j| + |j - k| + |k - i| 💻 Key Code Insight: Instead of checking all combinations, I only checked sliding windows of size 3 within index lists — reducing unnecessary work. 🧠 Learning: Even in medium problems, a simple structured approach (grouping + sliding window) can pass efficiently when applied correctly. ⚡ Complexity: Time: O(n) to build map + O(n) traversal Space: O(n) 💬 Takeaway: Don’t overcomplicate — sometimes the same idea from an easy problem scales well with just a small optimization in thinking. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Tech #Programming #Developers #100DaysOfCode

🧠 After learning Dependency Injection, I explored one practical Spring Boot best practice today 👀 Constructor Injection vs Field Injection At first, field injection looked easier 👇 @Autowired private UserService service; But while going deeper, I realized why most production-grade projects prefer constructor injection 🚀 ✅ Dependencies are explicit ✅ Easier to unit test ✅ Works well with final fields ✅ Better immutability ✅ Cleaner and safer design 💡 My takeaway: Field injection may feel quick, but constructor injection makes the architecture much more maintainable in real-world applications. Tiny design choices create huge long-term impact ⚡ #Java #SpringBoot #DependencyInjection #BackendDevelopment #LearningInPublic

LeetCode Challenge – Day 48 Today I solved the House Robber problem. Problem Insight: Given an array where each element represents money in a house, the goal is to find the maximum amount that can be robbed without robbing two adjacent houses. Approach: At each house, there are two choices: Rob the current house and add its value to the maximum from two houses back Skip the current house and take the maximum till the previous house Used a dynamic programming approach to make this decision efficiently Key Learning: Dynamic Programming becomes easier when we break the problem into small decisions. At each step, we only need to decide whether to pick or skip the current element. Complexity: Time: O(n) Space: O(1) This problem helped me understand how to make optimal decisions using previous results. #LeetCode #Java #DSA #CodingJourney

🔥 Day 57/100 Today’s problem was all about smart string merging using Dynamic Programming 💡 👉 Problem: Minimize the final string length after performing join operations with overlap conditions. 🧠 Key Learning: Instead of building the full string (which is costly), I learned to optimize by tracking only: - First character - Last character - Current length This reduced the complexity drastically and made the solution efficient ⚡ 💻 Concepts Used: - Dynamic Programming (DP) - State Optimization - Greedy Thinking + Decision Making ✨ Takeaway: Sometimes, you don’t need the entire data — just the important parts to make decisions. Consistency > Motivation 🚀 See you on Day 58! #Day57 #Java #DSA #CodingJourney #PlacementPrep #LearnInPublic #100DaysOfCode

🚀 Day 90 — LeetCode Practice 🚀 Today’s focus was on bit manipulation and pattern recognition. ✅ Problem Solved: 🔹 Counting Bits 💡 Key Learnings from Today: • Learned how to count set bits (1s) in binary representation • Strengthened understanding of division by 2 and modulo operations • Explored how numbers behave in binary format • Improved problem-solving using iterative approach • Practiced writing clean and efficient logic 📌 Approach Used: Iterated through each number from 0 to n and counted the number of 1s in its binary form using a loop. 🎯 Next Step: Will optimize this using Dynamic Programming (DP) for better performance. Day by day improving consistency and logic 💪 #Day90 #LeetCode #CodingJourney #Java #ProblemSolving #Consistency

Day 55/100 – LeetCode Challenge Problem: Triangle Today I solved the “Triangle” problem, which is a classic dynamic programming question focused on finding the minimum path sum from top to bottom. Instead of starting from the top and exploring all possible paths, I approached this problem from the bottom. I initialized a DP array with the values of the last row of the triangle. Then, I moved upward row by row, updating each element by adding the minimum of the two adjacent values from the row below. This bottom-up approach reduces the problem size at each step and avoids unnecessary recomputation. By the time I reached the top, the first element of the DP array represented the minimum path sum. This method is efficient because it reuses space and avoids building a full 2D DP table. The solution runs in O(n²) time with O(n) space complexity. This problem reinforced how changing the direction of thinking — bottom-up instead of top-down — can simplify dynamic programming problems significantly. Fifty-five days in. The focus is now on writing optimal solutions with better space efficiency. #100DaysOfLeetCode #Java #DSA #DynamicProgramming #ProblemSolving #Consistency

🚀 Day 66 of #LeetCode Challenge ✅ Problem Solved: Divide a String Into Groups of Size K 💡 What I learned today: • Learned how to break a string into fixed-size groups • Understood how to handle incomplete groups using a fill character • Practiced building strings step-by-step using loops • Improved clarity on index handling and conditions 🧠 Approach: • Traverse the string one character at a time • Build a group until it reaches size k • Store the group and reset • If the last group is smaller, fill remaining positions with the given character 📊 Key Takeaway: Handling edge cases (like incomplete groups) is very important in problem solving 🔥 Consistency is the key — improving step by step every day! #Day66 #LeetCode #CodingJourney #DSA #Java #ProblemSolving #Consistency

Day 63 of Practicing DSA (LeetCode && Competitive Programming) Today’s progress: LeetCode • Longest Common Prefix – Easy Focused on: • Sorting-based approach for string comparison • Comparing first and last strings to find common prefix • Understanding optimization in string problems • Writing clean and concise logic This problem improved my understanding of efficient string handling techniques. Competitive Programming • Continued practicing problem-solving patterns Improved my thinking on: • Breaking down string problems logically • Writing optimized and readable code Simple problem, but strong fundamentals matter 💯 Consistency is the real key 🔥 #DSA #Java #LeetCode #Codeforces #Strings #ProblemSolving #Consistency #LearningInPublic 🚀