LeetCode 1411: N x 3 Grid Colorings with Dynamic Programming

🚀 Day 70 of #100DaysOfCode Solved LeetCode Problem #3651 – Minimum Cost Path with Teleportations ✅ This problem combined dynamic programming with smart state transitions to handle teleportations efficiently. Managing extra dimensions in DP while keeping transitions optimal was the real challenge here. Key Learnings: -> Modeling teleportations as additional DP states -> Using multi-dimensional DP for constrained movements -> Optimizing transitions with prefix minimum techniques -> Handling large state spaces without timeouts Language Used: Java -> Runtime: 188 ms (Beats 40.58%) -> Memory: 48.29 MB (Beats 28.99%) Step by step, leveling up problem-solving depth 🚀 Onwards to the next challenge 💪 #LeetCode #DynamicProgramming #Java #ProblemSolving #100DaysOfCode

🚀 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-119) 🔥 Solved LeetCode Hard Problem #1411 – Number of Ways to Paint N × 3 Grid (Java) Successfully implemented an optimized Dynamic Programming solution to count valid color combinations while ensuring no adjacent cells share the same color. 💡 Key Learnings: ✔️ State-based DP optimization ✔️ Handling large constraints using modulo arithmetic ✔️ Reducing space complexity with rolling variables Challenging problems like this help sharpen logical thinking and problem-solving skills 🚀 #LeetCode #HardProblem #DynamicProgramming #Java #DSA #ProblemSolving #CodingPractice #Algorithms #ComputerScience #DailyCoding

🚀 Day 72 of #100DaysOfCode Solved LeetCode Problem #2977 – Minimum Cost to Convert String II ✅ This was a more advanced follow-up that required handling string-level transformations efficiently. The challenge was to minimize the total cost by choosing optimal substring conversions rather than single-character changes. Key Learnings: -> Using a Trie to store and index valid string transformations -> Modeling transformation costs with dynamic programming -> Combining Trie traversal + DP for efficient substring matching -> Carefully managing state transitions to avoid unnecessary recomputation Language Used: Java -> Runtime: 209 ms (Beats 34.88%) -> Memory: 48.68 MB (Beats 18.60%) Step by step, leveling up problem-solving depth and string algorithm intuition 🚀 #LeetCode #DynamicProgramming #Trie #Java #ProblemSolving #100DaysOfCode

🚀 Day 90/100 - Problem of the day :- Number of Ways to Paint N x 3 Grid. 🎯 Goal Efficiently compute the total number of valid ways using dynamic programming with modular arithmetic. 💡 Core Idea Use DP with two state arrays to build results iteratively, applying recurrence relations and modulo to handle large values. 🔑 Key Takeaway Breaking a problem into well-defined states makes complex counting problems manageable and scalable. 📦 Space Complexity: O(n) ⏱️ Time Complexity: O(n) #LeetCode #DynamicProgramming #Java #ProblemSolving #DSA #CodingJourney #Consistency #100DaysChallenge

🔹 Day 91 – LeetCode Practice 📌 Problem: Three Consecutive Odds (LeetCode #1550) 📊 Difficulty: Easy 🧠 Problem Overview: Given an integer array, determine whether there are three consecutive odd numbers appearing next to each other. Return true if such a sequence exists; otherwise, return false. ✅ My Approach: Traversed the array while keeping track of consecutive odd numbers. Increased a counter whenever an odd number appeared and reset it when an even number was found. As soon as the counter reached three, the condition was satisfied. 📈 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) 🚀 Submission Results: Status: Accepted ✅ Runtime: 0 ms (Beats 100%) 🚀 Memory: 44.18 MB (Beats 38.42%) 💡 Reflection: This problem highlights how a simple counter-based logic can efficiently solve pattern-detection tasks. Clean logic and early exits make solutions both fast and readable. #LeetCode #DSA #Java #ProblemSolving #CodingPractice #LearningJourney

🚀 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 67 of #100DaysOfCode Solved LeetCode Problem #1984 – Minimum Difference Between Highest and Lowest of K Scores ✅ This problem focused on minimizing the score gap by smartly selecting k elements after sorting the array. A perfect example of how sorting + sliding window logic can turn a problem simple and efficient. Key Learnings: -> Sorting simplifies comparisons -> Sliding window to evaluate consecutive groups of size k -> Avoid brute force by leveraging order -> Small observations lead to clean solutions Language Used: Java -> Runtime: 8 ms (Beats 89.22%) -> Memory: 47.09 MB (Beats 25.34%) Consistency > Intensity 💪 On to the next challenge 🚀 #LeetCode #Java #ProblemSolving #Algorithms #Sorting #SlidingWindow #100DaysOfCode

#Day-126) LeetCode 712: Minimum ASCII Delete Sum for Two Strings ✅ In this problem, I implemented a Dynamic Programming approach to compute the minimum ASCII value of characters that must be deleted from two strings to make them equal. 🔍 What I learned: Designing DP states for string comparison Handling base cases efficiently Optimizing decisions using minimum cost strategies This challenge improved my problem-solving skills and reinforced core DSA concepts. 📌 Language: Java 📌 Topic: Dynamic Programming #LeetCode #DSA #DynamicProgramming #JavaDeveloper #ProblemSolving #CodingPractice #TechJourney