LeetCode 3651: Minimum Cost Path with Teleportations in Java

100 Days of Coding Challenge – Day 1 📌 Problem: Rotate Matrix (90° Clockwise) 🧠 Concepts Used: 2D Arrays, In-place Matrix Rotation 💻 Language: Java 🔍 Platform: LeetCode Solved the classic Rotate Image problem by modifying the matrix in-place without using extra space. A great start to strengthen problem-solving with matrices! 🔗 Code: https://lnkd.in/gZJFvDYv 🔗 Problem: https://lnkd.in/gcGZp4p3 #100DaysOfCode #Day1 #Java #DSA #LeetCode #CodingJourney #ProblemSolving

🚀 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 75 of #100DaysOfCode Solved LeetCode Problem #3013 – Divide an Array Into Subarrays With Minimum Cost II ✅ This one was a step up from Part I — combining sliding window logic with ordered data structures (TreeSet) to efficiently track minimum costs under constraints. Key Takeaways: -> Smart use of TreeSet for dynamic minimum tracking -> Handling window constraints (k, dist) cleanly -> Balancing correctness with performance in greedy-style problems -> Thinking beyond brute force for optimization Language: Java -> Runtime: 332 ms (Beats 47.83%) -> Memory: 105.54 MB Consistency > Perfection. One problem at a time. 💻🔥 #LeetCode #Java #DataStructures #Greedy #SlidingWindow #ProblemSolving #100DaysOfCode

Strings look simple until edge cases show up 👀 Day 8 / #100DaysOfCode 🚀 Solved: Valid Palindrome (LeetCode 125) 🔹 Approach: Used the two-pointer technique starting from both ends. Ignored non-alphanumeric characters and compared characters after converting the string to lowercase. Time Complexity: O(n) Space Complexity: O(1) ✔ Practiced string traversal with pointers ✔ Handled real-world edge cases (spaces, symbols, cases) ✔ Avoided extra space by working in-place 💡 Takeaway: Clean pointer logic often beats preprocessing with extra data structures. Building strong fundamentals in Java, one problem at a time. #LearnInPublic #100DaysOfCode #DSA #Java #Strings #ProblemSolving #SoftwareEngineer #CodingJourney #Consistency

Continued the matrix LeetCode practice with 48. Rotate Image. Unlike transpose, this problem required rotating the matrix in-place, which means no extra matrix could be used. That constraint made the logic more interesting. Approach used: - first performed a transpose across the main diagonal - then reversed each row to complete the 90° clockwise rotation - kept the focus on clear index manipulation instead of complex tricks Result : Accepted Runtime : 0 ms Clean in-place transformation without extra space Key learning from this problem: - many matrix rotations are just transpose + reverse in disguise - in-place operations demand careful index handling - understanding the pattern is more valuable than memorizing code This felt like a natural step forward from transpose toward more complex traversal and matrix logic. #LeetCode #DSA #Matrices #Java #ProblemSolving #CodingJourney #LearningInPublic #JavaDeveloper

🎯 Day 67 of #100DaysOfCode 📌 Problem: Combination Sum Today's challenge was all about finding all unique combinations of candidates where the chosen numbers sum to a given target. The same number can be used unlimited times, and combinations must be unique. 🧠 Approach: Used dynamic programming with a 3D list structure dp[t] stores all combinations that sum to target t Iterated through candidates and built combinations from smaller sums Extended each valid combination by adding current candidate 📊 Stats: ✅ 160/160 test cases passed ⚡ Runtime: 5 ms | Beats 10.10% 💾 Memory: 46.71 MB | Beats 5.88% 📝 Takeaway: This problem highlighted the trade-off between intuitive DP solutions and optimization. While the approach works, there's room for improvement in both runtime and memory efficiency. Backtracking might be a more elegant solution here! 🔗 Problem: Combination Sum 🏷️ #LeetCode #CodingChallenge #Java #DynamicProgramming #Backtracking #Algorithms #TechJourney #ProblemSolving

Day 46/200 – LeetCode Challenge Multiply Strings Today’s focus was on implementing string-based multiplication without using built-in big integer libraries. The solution involved simulating manual multiplication using an integer array for positional sums. This approach ensured efficiency and accuracy even for very large inputs. Optimizing nested loops and handling digit positions carefully can significantly improve runtime in high-precision arithmetic problems. Continuing the 200-day journey with consistent progress #LeetCode #CodingChallenge #Java #ProblemSolving #200DaysOfCode #LearningEveryday

Day 17/100 – LeetCode Challenge 🚀 Problem: Fibonacci Number Approach: Used iterative dynamic programming Maintained only the last two values instead of storing the whole sequence Time Complexity: O(n) Space Complexity: O(1) Key takeaway: Dynamic programming is often about reducing repeated work, and many DP problems can be optimized to constant space. #LeetCode #100DaysOfCode #DSA #Java #ProblemSolving #InterviewPrep #100DaysOfLeetCode

Day 16 – LeetCode 1004 | Sliding Window Done Right (O(n) Solution) Day 16 of solving problems consistently. Solved LeetCode 1004 – Max Consecutive Ones III. Problem: Given a binary array, you can flip at most k zeros. Return the maximum number of consecutive 1s possible. Brute force checks every subarray → O(n²) → wasteful. A better approach is Sliding Window + Two Pointers → O(n). Core logic: • Expand window with right pointer • Count zeros • If zeros exceed k → move left pointer • Track max window length This problem is a good reminder that: Constraints usually hint the optimal technique. If you see “subarray + max/min + linear time” → think Sliding Window first. Consistency builds skill. 16 days. No breaks. Code + explanation in the video 👇 #LeetCode #DSA #Algorithms #SlidingWindow #TwoPointers #Java #ProblemSolving #CodingInterview #SoftwareDeveloper #100DaysOfCode #TechJourney

🚀 Day 44 Out of #365DayOfCode - LeetCode Today I worked on the Set Matrix Zeroes problem, where the goal is to modify a 2D matrix such that if any element is 0, its entire row and column are set to 0. I implemented an efficient solution with O(m × n) time complexity and optimized space usage by carefully handling matrix traversal and edge cases. This problem helped me strengthen my understanding of: 2D array manipulation In-place updates Optimizing space complexity Handling edge cases in algorithms Consistent practice is helping me improve my problem-solving skills step by step. 🚀 #DSA #Java #ProblemSolving #CodingPractice #365DaysOfCode Github link: https://lnkd.in/gGUy_MKZ