Dynamic Programming for N x 3 Grid Painting Problem

#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 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 48 of My Daily Coding Challenge 🚀 Today I implemented In-Place Merge Sort using Recursion — focusing on sorting the array without creating new subarrays. 📌 What I worked on: • Dividing the array using start, mid, and end indices • Recursively sorting left and right halves • Merging both halves back within the same array using a temporary buffer • Careful index handling to avoid extra space overhead 💡 Key Learning: Understanding how indices flow in recursion is crucial for writing efficient, in-place algorithms. This approach strengthened my grasp of divide-and-conquer logic and memory handling. 🔗 Solution (Java):[https://lnkd.in/dBM-nBCC] #100DaysOfCode #Day48 #Java #DSA #MergeSort #InPlaceAlgorithm #Recursion #ProblemSolving #CodingJourney #LearnInPublic

🔥 Day 305 – Daily DSA Challenge! 🔥 Problem: 📦 Subsets (Power Set) Given an integer array nums of unique elements, return all possible subsets (the power set). 💡 Key Insights: 🔹 Every element has two choices → include it or exclude it. 🔹 The total number of subsets for n elements is 2ⁿ. 🔹 Backtracking helps explore all possibilities in a clean, structured way. 🔹 Add the current subset to the result at every recursion level. 🔹 Move forward using i + 1 to avoid reusing elements. ⚡ Optimized Plan: ✅ Start with an empty subset ✅ Use backtracking to build subsets incrementally ✅ Add the current subset to results before branching further ✅ Try including each remaining element one by one ✅ Backtrack after exploring each choice ✅ Time Complexity: O(2ⁿ) ✅ Space Complexity: O(n) (recursion depth) 💬 Challenge for you: 1️⃣ How would this change if nums contained duplicate elements? 2️⃣ Can you solve this using bit masking instead of recursion? 3️⃣ How would you generate subsets of exactly k elements? #DSA #Day305 #LeetCode #Backtracking #Recursion #PowerSet #Java #ProblemSolving #KeepCoding #100DaysOfCode

🚀 Day 91/100 - Problem of the day :- Four Divisors. 🎯 Goal Solve the problem efficiently by identifying numbers with exactly four divisors and calculating their sum. 💡 Core Idea Iterate through each number, find divisors up to √n, count them smartly, and stop early once divisors exceed four. 📌 Key Takeaway Optimizing divisor checks with early termination significantly improves performance. 🧠 Space Complexity: O(1) ⏱️ Time Complexity: O(n · √k), where k is the maximum value in the array. #LeetCode #DSA #Java #ProblemSolving #CodingJourney #Algorithms #Efficiency #100DaysChallenge

🚀 Day 50 of #100DaysOfCode 🎯 (Halfway there! 🔥) Today’s challenge was an array + dynamic programming twist problem — 📊 LeetCode: Maximum Product Subarray 📌 Problem Summary Given an integer array, find the contiguous subarray (containing at least one number) that has the largest product. At first glance, it looks similar to maximum subarray sum… but the presence of negative numbers changes everything ⚠️ 🧠 My Approach: Tracking Max & Min Products The key insight 👇 A negative number can turn the smallest product into the largest. So instead of tracking only the maximum, I tracked: ✅ max product ending at current index ✅ min product ending at current index At each step: Compute new max using (current, max*current, min*current) Compute new min similarly Update the global result This keeps everything in one pass 🚀 ⚙️ Complexity Analysis ⏱ Time: O(n) 💾 Space: O(1) Efficient and clean ✨ 🔥 Key Learning Negative numbers can flip the problem logic Some DP problems don’t need arrays — just smart state tracking Always think in terms of states, not just values ✅ Solution accepted with strong runtime performance Another powerful array pattern mastered 💪 Onward from Day 50 — the grind continues 🚀🔥 #100DaysOfCode #LeetCode #Java #DynamicProgramming #Arrays #ProblemSolving #CodingJourney #DSA

🚀 Binary Tree Maximum Path Sum 🌳🧠 Just completed LeetCode – Binary Tree Maximum Path Sum, one of the classic Hard problems that truly tests your understanding of tree DFS + recursion + dynamic programming concepts. 🔍 Key Learnings: A path can start and end at any node (not necessarily the root). At each node, we must consider three possibilities: Path passing through the node (left + node + right) Path extending from one side only (to be returned to parent) Path consisting of the node alone (important for negative values) Maintained a global maximum to track the best path sum seen so far. 🧠 Core Insight: The value returned to the parent must be a single-sided path The global answer may include both children, but cannot be extended upward ⚙️ Complexity: Time: O(n) — each node visited once Space: O(h) — recursion stack (h = tree height) This problem significantly strengthened my understanding of: DFS traversal patterns Handling negative values in trees Separating global answers from recursive return values #LeetCode #DSA #BinaryTree #DynamicProgramming #Recursion #Java #ProblemSolving #CodingJourney #SoftwareEngineering #LearningByDoing

🚀 Day 488 of #500DaysOfCode 📌 LeetCode Problem: 2976. Minimum Cost to Convert String I Today’s challenge was about minimizing the cost to convert one string into another using a set of given character transformation rules — each with an associated cost. 💡 Key Idea: Model this as a graph problem where each lowercase character is a node, and every transformation is a directed edge with a cost. Then use Floyd–Warshall to compute the minimum conversion cost between all pairs of characters. 🔍 Approach Summary: ✔ Build a 26×26 cost matrix for all character conversions ✔ Use Floyd–Warshall to find the cheapest paths ✔ For each position in the string, sum the cost of converting source[i] → target[i] ✔ Return the total cost — or -1 if impossible ⚙️ Time Complexity: 26³ for preprocessing + O(n) for string traversal, which is efficient even for large inputs. 💬 What I learned today: Graph applications go beyond nodes and edges — even string transformations can be mapped beautifully as a shortest path problem! 🔁 Keep coding. Keep growing. #java #leetcode #codingchallenge #graphalgorithms #floydwarshall

📅 Day 62 of #100DaysOfLeetCode 🔢 Problem: 1458. Max Dot Product of Two Subsequences 🟥 Difficulty: Hard 🧠 Problem Summary Given two integer arrays, find the maximum dot product between non-empty subsequences of equal length while preserving order. 💡 Key Insight This problem is a DP + subsequence variant similar to LCS, but with an important twist: 👉 The answer can be negative, so initializing DP with 0 will fail. 👉 We must ensure at least one pair is chosen. 🚀 Approach (Memoization / Top-Down DP) Use recursion with indices (i, j) At each step, consider: Pairing nums1[i] with nums2[j] Skipping an element from either array Use Math.max(0, previous) to avoid extending negative subsequences Memoize results to achieve O(n × m) complexity ⏱ Complexity Time: O(n × m) Space: O(n × m) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

#LeetCode 76: Minimum Window Substring – A Masterclass in Logic. I used to think I knew Sliding Window, but this Hard-level problem challenged my assumptions. It’s less about the loop and more about the order of operations. I learned that updating the minimum window at the wrong micro-step can lead to hours of debugging. It was a solid reminder that in technical interviews and real-world dev, small conditions can silently break correct-looking logic. Focus on the logic; the code will follow. #Coding #Java #LearningToCode #DataStructures #SlidingWindow