Maximizing Path Score in Grid with Cost Constraint

🚀 Code 9 – #50LeetCodeChallenge 🧩 Problem: Pascal’s Triangle II Given an integer rowIndex, return the corresponding row (0-indexed) of Pascal’s Triangle. In this triangle, each element is formed by adding the two elements directly above it. 💡 Approach: Instead of generating the entire triangle, we can optimize space by building only the required row: • Start with a list initialized as [1] • For each new row, update the existing list from right to left • Each element is updated as: current[j] = current[j] + current[j - 1] • Append 1 at the end after each iteration Updating from right to left ensures that we don’t overwrite values needed for computation. 📚 Key Takeaway: By using in-place updates, we reduce space complexity to O(k) while maintaining a time complexity of O(k²). This is a great example of optimizing space in dynamic programming problems. #LeetCode #Java #Coding #ProblemSolving #DynamicProgramming #Arrays #Programming

🚀 Day 26 of #100DaysOfCode — still going strong! Today I tackled LeetCode 6 – Zigzag Conversion 🔤 The problem: Write a string in a zigzag pattern across N rows, then read it row by row. "PAYPALISHIRING" across 3 rows becomes → "PAHNAPLSIIGYIR" Seems visual at first — but the real trick is finding the mathematical pattern! 🧠 My approach (Java): ✅ Edge case: if numRows == 1, return the string directly ✅ Use a StringBuilder for the result ✅ For each row i, jump by (2 * (numRows - 1)) to get the main character ✅ For middle rows, also grab the diagonal character at offset (2 * (numRows - 1) - 2 * i) Result: 3ms runtime — beats 93.63% of submissions 🔥 Memory: 46.35 MB — beats 87.58% 💪 Key insight: → No need to simulate the actual zigzag grid — just calculate the index offsets mathematically → Middle rows always have TWO characters per cycle; first and last rows have ONE → Math > simulation when it comes to performance Visualize the pattern, then kill it with math. 💡 #LeetCode #Java #DSA #100DaysOfCode #CodingChallenge #Programming #ProblemSolving #SoftwareDevelopment

Day 55/100 – LeetCode Challenge Problem: Triangle Today I solved the “Triangle” problem, which is a classic dynamic programming question focused on finding the minimum path sum from top to bottom. Instead of starting from the top and exploring all possible paths, I approached this problem from the bottom. I initialized a DP array with the values of the last row of the triangle. Then, I moved upward row by row, updating each element by adding the minimum of the two adjacent values from the row below. This bottom-up approach reduces the problem size at each step and avoids unnecessary recomputation. By the time I reached the top, the first element of the DP array represented the minimum path sum. This method is efficient because it reuses space and avoids building a full 2D DP table. The solution runs in O(n²) time with O(n) space complexity. This problem reinforced how changing the direction of thinking — bottom-up instead of top-down — can simplify dynamic programming problems significantly. Fifty-five days in. The focus is now on writing optimal solutions with better space efficiency. #100DaysOfLeetCode #Java #DSA #DynamicProgramming #ProblemSolving #Consistency

🚀 LeetCode — Problem 1456 | Day 15 💡 Problem: Maximum Number of Vowels in a Substring of Given Length --- 🧠 Problem: Given a string s and an integer k, find the maximum number of vowels in any substring of length k. --- 🧠 Approach (Sliding Window): - First, count vowels in the first window of size k - Then slide the window: • Remove the left character (if vowel → count--) • Add the new right character (if vowel → count++) - Track maximum count during traversal 👉 Key idea: Reuse previous window instead of recalculating --- ⚙️ Core Logic: - Initialize count for first k characters - For every step: count = count - oldChar + newChar - Update maxCount --- ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) --- ⚠️ Edge Cases: - k = 1 → check each character - All vowels → max = k - No vowels → return 0 - k = string length → single window --- 🔍 Insight: Sliding window avoids recalculating each substring → makes it efficient --- 🔑 Key Learning: - Classic Sliding Window pattern - Efficient range-based computation - Avoid redundant work --- "Use sliding window to maintain vowel count and update it in O(1) per step." --- #LeetCode #DSA #Java #SlidingWindow #CodingJourney

Day 102: The Two-Finger Typing Grind ⌨️✌️ Problem 1320: Minimum Distance to Type a Word Today’s solve was about minimizing movement on a 6×5 keyboard layout. The Strategy: • Optimization via Savings: Instead of just calculating distance, I used Dynamic Programming to find the maximum "cost saved" by utilizing a second finger. • Efficient DP State: dp[c] tracks the max distance saved with the second finger at character c, allowing me to find the optimal path in a single pass. By focusing on "distance saved" rather than "total cost," the logic becomes much faster and cleaner. Day 102—keep optimizing. 🚀 #LeetCode #Java #DynamicProgramming #Algorithms #DailyCode

🚀 Day 22 of 180 — Longest Substring Without Repeating Characters ✅ LeetCode 3 — Longest Substring Without Repeating Characters Classic sliding window problem. Find the longest substring with all unique characters. Used a HashMap to store each character with its last seen index instead of frequency. This is the key difference from previous sliding window problems. Slide r through the string. If current character already exists in map AND its last seen index is within current window (>= l) — move l to one position ahead of that last seen index. This way the duplicate is removed from the window. Then update the character's index in map and calculate max window size. The tricky part — even if character exists in map, only move l if that character is actually inside the current window. If it's behind l already, no need to shrink. Day 22 done. 158 to go. 🔥 #180DaysDSA #Day22 #LeetCode #Java #DSA #SlidingWindow #HashMap #Strings #DSAJourney #CodingJourney #Programming #DataStructures #Algorithms #ProblemSolving #BuildInPublic #CodeNewbie #LearnToCode #100DaysOfCode #SoftwareDevelopment #Developer #StudentDeveloper #TechCommunity #LinkedInTech #CompetitiveProgramming

Day 41 #SDE stack-based validation and dynamic programming on strings. Solved: • Bracket Challenge • Word Break Key Learning: • “Bracket Challenge” reinforces the use of a stack to validate balanced parentheses and handle nested structures efficiently. • “Word Break” revisited the DP + memoization approach, where we check valid segmentations of a string using a dictionary. #LeetCode #DSA #Stack #DynamicProgramming #Algorithms #Java #SoftwareEngineering

Day 32/50 – LeetCode Challenge 🧩 Problem #416 – Partition Equal Subset Sum Today’s problem focused on determining whether an array can be divided into two subsets with equal sum, which is a classic Dynamic Programming (Subset Sum) problem. 📌 Problem Summary: Given an array of integers, check if it can be partitioned into two subsets such that their sums are equal. 🔍 Approach Used ✔ First calculated the total sum of the array ✔ If the sum is odd → not possible to divide equally ✔ Converted the problem into: Can we find a subset with sum = total / 2 ? ✔ Used a set (DP approach) to store all possible sums ✔ Iteratively built new sums by adding each number ✔ Checked if the target sum exists ⏱ Time Complexity: O(n × target) 📦 Space Complexity: O(target) 💡 Key Learning ✔ Converting problems into Subset Sum pattern ✔ Using Dynamic Programming with sets ✔ Thinking in terms of possibility instead of brute force ✔ Recognizing important DP patterns This problem helped me understand how to simplify complex problems into familiar patterns. Consistency builds strong problem-solving intuition 🚀 🔗 Problem Link: https://lnkd.in/gCRhSyaz #50DaysOfLeetCode #LeetCode #DSA #DynamicProgramming #SubsetSum #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

🚀 Solved: LeetCode 494 — Target Sum (DP + Knapsack Transformation) Another step deeper into Dynamic Programming patterns. At first glance, this problem looks like a recursion/backtracking problem (assign + / -). But the real breakthrough comes from transforming it into a 0/1 Knapsack (counting) problem. 🧠 Key Insight Instead of thinking in terms of signs: Split into two subsets: P (positive), N (negative) Which leads to: P - N = target P + N = total 👉 Reduces to: Find subsets with sum = (target + total) / 2 💡 From here, it becomes a subset sum count problem I implemented: • Top-Down (Memoization) • Bottom-Up (2D DP) • Bottom-Up (1D Optimized — best approach) ⚡ Final Optimized Approach (1D DP) State: dp[j] = number of ways to make sum j Transition: dp[j] += dp[j - num] Traverse right → left to maintain 0/1 constraint 🔥 Key Learning Same pattern, different behavior: 416 → boolean (can we form?) 494 → count (how many ways?) Understanding this shift is what makes DP reusable across problems. 🔗 LeetCode Profile: https://lnkd.in/d6CKa-BN 🔗 GitHub Repo: https://lnkd.in/gnEfmGAg #leetcode #dsa #dynamicprogramming #knapsack #java #codinginterview #softwareengineering

🚀 Day 15 of 180 — 3Sum Closest ✅ LeetCode 16 — 3Sum Closest First sort the array. Then fix one element and use two pointers for the remaining two — one at left, one at right. For every triplet I calculate the sum and check how far it is from the target: distance = |target - sum| If this distance is less than my current minimum difference, I update my answer. Moving pointers is simple — if sum is greater than target → move right pointer left if sum is less than target → move left pointer right if sum equals target → that's the closest it can get, return immediately The key thing I made sure — keep tracking the minimum difference throughout and update result whenever a closer sum is found. Day 15 done. 165 to go. 🔥 #180DaysDSA #Day15 #LeetCode #Java #DSA #TwoPointers #Sorting #ThreeSum #DSAJourney #CodingJourney #Programming #DataStructures #Algorithms #ProblemSolving #BuildInPublic #CodeNewbie #LearnToCode #100DaysOfCode #SoftwareDevelopment #Developer #StudentDeveloper #TechCommunity #LinkedInTech #CompetitiveProgramming