LeetCode 62: Unique Paths with Dynamic Programming

🚀 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 472 of my #500DaysOfCode challenge 🚀 ✅ LeetCode 3453: Separate Squares I (Medium) 📌 Problem Summary: We are given multiple squares on a 2D plane, each defined by bottom-left coordinate (x, y) and side length (l). The task is to find the minimum y-coordinate of a horizontal line such that: ✅ Total area above the line = Total area below the line ⚠️ Important note: Squares may overlap, and overlapping area should be counted multiple times (each square contributes independently). 💡 Key Insight: For any horizontal line y = mid, each square contributes to the area below based on how much of its height lies below the line: If the line is below the square → contributes 0 If the line is above the square → contributes full area l² If the line cuts the square → contributes l * (mid - y) Since the area below increases monotonically as the line moves upward, we can apply: ✅ Binary Search on the y-coordinate 🎯 Goal: Find smallest y where areaBelow(y) ≥ totalArea / 2. ⚡ Complexity: ✅ Time: O(n log range) (binary search iterations × n squares) ✅ Space: O(1) This was a great problem to reinforce how binary search can be used beyond arrays, especially when the function is monotonic 📈. #leetcode #dsa #java #binarysearch #programming #problemsolving #500daysofcode #consistency #learning

🚀 Day 57 of #100DaysOfCode Today’s problem was a clean and classic two-pointer exercise — 🔁 LeetCode 344: Reverse String Simple on the surface, but a great reminder of in-place algorithms and pointer manipulation. 📌 Problem Summary You’re given a character array s. Your task is to reverse the array in-place, using O(1) extra space. 🧠 Approach Used: Two Pointers ✔️ Initialize: left = 0 right = s.length - 1 ✔️ Swap characters while left < right, then move pointers inward. This ensures: No extra memory Linear traversal Clean and readable logic ⚙️ Complexity Analysis ⏱ Time Complexity: O(n) 💾 Space Complexity: O(1) (in-place) ✔️ 477 / 477 test cases passed 🚀 Runtime: 0 ms (Beats 100%) 🔥 Key Learning Even the simplest problems reinforce core fundamentals: Two-pointer technique In-place operations Space optimization Mastering basics = dominating harder problems later 💪 Onward to Day 58 🚀 #100DaysOfCode #LeetCode #ReverseString #TwoPointers #Java #DSA #ProblemSolving #CodingJourney #Consistency

🚀 Day 467 of #500DaysOfCode 📌 Problem Solved: 1458. Max Dot Product of Two Subsequences (Hard) Today’s problem was a reminder that not all subsequence problems are greedy-friendly. We’re given two arrays and asked to find non-empty subsequences whose dot product is maximized. Sounds simple at first — until negative numbers enter the picture. 💡 Key Realization: This problem is similar to LCS, but instead of matching characters, we’re: pairing numbers, multiplying them, and deciding whether to take or skip each element. The tricky part? 👉 We cannot choose empty subsequences, and sometimes the best answer is negative. 🧠 Approach Used: Used 2D Dynamic Programming dp[i][j] represents the maximum dot product using prefixes of both arrays At each step, we decide to: take the current pair, skip an element from the first array, or skip one from the second A key trick was using max(previous, 0) to safely start a new subsequence when needed ⚙️ Concepts Reinforced: Dynamic Programming on two sequences Handling negative values correctly Non-empty subsequence constraints Why initialization matters in DP 🔥 Hard problems like this really sharpen DP intuition and edge-case thinking. On to Day 468 🚀 #LeetCode #DynamicProgramming #HardProblems #ProblemSolving #Java #DSA #Consistency #CodingJourney #500DaysOfCode

🚀 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

🚀 Solved LeetCode 338: Counting Bits 🚀 I recently worked on the Counting Bits problem, where the task is: 👉 Given an integer n, return an array ans of length n + 1 such that for each i (0 <= i <= n), ans[i] is the number of 1's in the binary representation of i. 🔹 My Approach: Initialize an array of size n+1. For each number from 1 to n: Copy the number into a temporary variable. Use a loop to repeatedly divide by 2, counting the remainder (num % 2) each time. Store the total count of 1’s in the array. Return the final array. 📊 Complexity Analysis: Time Complexity: O(n log n) Each number requires about log(i) steps to process its binary digits. Space Complexity: O(n) Only the result array of size n+1 is used. ✨ Key Learning: This problem strengthened my understanding of binary representation and iterative problem solving. It was a great reminder that even simple bitwise operations can unlock powerful solutions. #LeetCode #Java #ProblemSolving #BackendDevelopment #CodingJourney #BitManipulation

🚀 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 47 | LeetCode Medium 🟩 Set Matrix Zeroes Today’s problem focused on matrix traversal + space trade-offs, and it was a great reminder that clarity beats complexity. 🧠 Core Idea If any cell in the matrix is 0, then its entire row and column must be set to 0. Instead of modifying the matrix immediately (which can break logic), I used an auxiliary tracking approach. 🛠️ Approach Used Traverse the matrix once Mark affected rows and columns using helper arrays Traverse again and update cells based on these markers This avoids incorrect cascading zeros and keeps the logic clean. ⚡ Why this works Separation of detection and update No accidental overwrites Easy to reason and debug ⏱️ Complexity Time: O(m × n) Space: O(m + n) 🔗 Code on GitHub 👉 https://lnkd.in/g-zxCztf 💡 Key Learning In matrix problems, when you update is just as important as what you update. 🔥 Consistency > Speed Another step forward in my daily DSA journey 🚀 #LeetCode #LeetCodeDailyProblem #SetMatrixZeroes #DSA #Java #Arrays #Matrix #ProblemSolving #CodingJourney #100DaysOfCode #TechCommunity

Clean code in Modern C++ isn’t about features, it’s about intent. Interfaces, ownership, value semantics, and explicit failure handling matter far more than clever abstractions, especially in long-lived systems. I put together a short article on what clean really means in Modern C++, drawing from fundamentals that scale in real-world codebases. #Cplusplus #SoftwareEngineering #CleanCode #SystemsProgramming #BackendEngineering #Programming #TechCareers