Maximizing Event Value with Java DP

🚀 Day 50 of #100DaysOfCode Solved LeetCode Problem #1458 – Max Dot Product of Two Subsequences ✅ This problem focused on finding the maximum dot product between non-empty subsequences of two arrays. The tricky part was handling negative values and ensuring at least one pair is always chosen. Key Learnings: -> Used Dynamic Programming with memoization to avoid recomputation -> Carefully handled the base case using Integer.MIN_VALUE to enforce non-empty subsequences -> Explored the classic include vs exclude decision at each index -> Strengthened understanding of DP on two sequences Language Used: Java -> Runtime: 11 ms (Beats 59.26%) -> Memory: 48.77 MB Step by step, sharpening DP intuition and edge-case handling 🚀 #LeetCode #DynamicProgramming #Java #ProblemSolving #100DaysOfCode

🚀 Day 45 of #100DaysOfCode Solved LeetCode Problem #1411 – Number of Ways to Paint N × 3 Grid 🎨 This problem focused on counting valid colorings of an N × 3 grid such that no two adjacent cells (horizontally or vertically) have the same color. The challenge was to recognize repeating patterns and optimize the solution using dynamic programming. Key Learnings: -> Broke the problem into two repeating pattern states (2-color & 3-color combinations) -> Derived recurrence relations to transition between rows -> Used constant space DP for optimal performance -> Reinforced how mathematical observation simplifies complex DP problems Language Used: Java -> Runtime: 2 ms (Beats 99.49%) -> Memory: 42.06 MB Dynamic programming becomes powerful when patterns are clearly identified 🚀 #LeetCode #DynamicProgramming #Java #ProblemSolving #100DaysOfCode #DSA

🚀 Day 52 of #100DaysOfCode Solved LeetCode Problem #712 – Minimum ASCII Delete Sum for Two Strings. This problem focused on minimizing the total ASCII value of deleted characters to make two strings equal. A classic dynamic programming challenge that required carefully defining states and transitions for optimal substructure. Key Learnings: -> Modeled the problem using DP on string indices -> Handled base cases when one string is fully consumed -> Used memoization to avoid overlapping subproblems Strengthened understanding of string DP and cost-based optimization Language Used: Java -> Runtime: 34 ms (Beats 7.60%) -> Memory: 50.39 MB Consistent practice, deeper DP intuition, and steady progress 🚀 #LeetCode #DynamicProgramming #Java #ProblemSolving #100DaysOfCode

#Day-108) LeetCode Challenge: 2054 – Two Best Non-Overlapping Events Today I solved an interesting problem that combines dynamic programming + binary search to maximize the sum of values from two non-overlapping events. 💡 Key takeaways: Sorting events by start time helps simplify the search. Binary search efficiently finds the next valid event after the current one. Dynamic programming ensures we don’t recompute overlapping subproblems. Here’s a snippet of my Java solution where I used recursion with memoization to optimize performance. 👉 This problem strengthened my ability to handle interval scheduling + optimization patterns, which are widely applicable in backend systems like scheduling tasks, resource allocation, and event management. I’d love to hear how others approached this problem—did you use a greedy strategy, DP, or another trick? Let’s discuss! #LeetCode #Java #DynamicProgramming #BinarySearch #ProblemSolving #CodingJourney

🚀 Day 62 of Daily LeetCode Practice Today’s focus: LeetCode Daily Question – “Maximum Number of Events That Can Be Attended II” 🧩 Solved it using an optimized approach in Java, combining: 📊 Sorting 🔍 Binary Search 🧠 Prefix Maximum DP ✨ Key Idea: Sort events by start time, maintain another array sorted by end time, and use a prefix max array to efficiently choose at most two non-overlapping events with maximum total value. ⚡ Performance Highlights: 🏎 Runtime: 37 ms (Beats 98%) 💾 Memory: 176.97 MB ✅ All test cases passed 💻 Language: Java This problem was a great reminder that clean preprocessing + smart searching can drastically improve performance. Consistency continues. Onward to Day 63 🚀 #Day60 #LeetCode #Java #DSA #ProblemSolving #DynamicProgramming #BinarySearch #CodingJourney #Consistency #SoftwareEngineering

Day 8/25 – LeetCode Challenge 🚀 🔸Problem: Find First and Last Position of Element in Sorted Array 🔸Difficulty: Medium 🔸Topic: Array, Searching 🔸Language: Java Approach 🛠️: ▫️Iterated through the array once to locate the target value. ▫️Tracked the first occurrence when the target is found initially. ▫️Continuously updated the last occurrence index for subsequent matches. ▫️Returned default values when the target does not exist in the array. ▫️This approach keeps the solution simple and easy to understand. Key Learnings 📚: 🔹Handling default values for edge cases is important 🔹Tracking first and last positions in a single pass 🔹Understanding problem constraints before optimizing 🔹Clean logic improves readability and debugging #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

🔹 Day 96 – LeetCode Practice 📌 Problem: First Missing Positive (LeetCode #41) 📊 Difficulty: Hard 🧠 Problem Overview: Given an unsorted integer array, the task is to find the smallest positive integer that is missing from the array. The challenge lies in solving it efficiently with strict constraints on time and space. ✅ Approach Used: Stored all values from the array for quick lookup. Iterated from the smallest possible positive integer to identify the first missing value. Returned the earliest number that was not present. 📈 Submission Results: Status: Accepted ✅ Runtime: 14 ms Memory Usage: 93.44 MB 💡 Reflection: This problem highlights the importance of understanding constraints clearly. While multiple approaches exist, optimizing time and space is the key learning takeaway from this question. #LeetCode #DSA #ProblemSolving #Arrays #Java #CodingJourney #Consistency

Day 2/25 – LeetCode Challenge 🚀 🔸Problem : Merge Sorted Array 🔸Difficulty : Easy 🔸Topic : Arrays, Three Pointers 🔸Language : Java Approach 🛠️ : ▫️Used a three-pointer technique starting from the end of both arrays. ▫️Compared elements from nums1 and nums2 and placed the larger one at the correct position. ▫️By filling nums1 from the back, avoided overwriting existing values. ▫️Continued until all elements from nums2 were merged. ▫️This ensures an in-place solution with optimal time complexity. Key Learnings 📚: 🔹Efficient use of two pointers for sorted arrays 🔹Importance of reverse traversal in in-place problems 🔹How to avoid extra space while merging arrays 🔹Reinforced understanding of array manipulation #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency