Climbing Stairs LeetCode 70 Solution

Hello connections, Here is my solution to a LeetCode dynamic programming problem. Time Complexity: O(N × M) Space Complexity: O(N × M) Learning from the problem: This problem requires carefully handling negative values while ensuring that at least one pair of elements is selected. By using dynamic programming and considering whether to take or skip elements from either array, we can build the maximum dot product step by step. A key insight is extending a subsequence only when it improves the total, otherwise starting fresh with the current pair. This is a great example of how DP helps manage multiple choices and constraints simultaneously. #leetcode #problemsolving #cpp #dynamicprogramming #arrays #datastructures #happycoding

🚀 LeetCode Daily Practice – Day 23 Problem: Minimum Falling Path Sum (Dynamic Programming) Today’s problem was about choosing a path through a matrix where each step gives limited movement options. It’s a great example of how DP helps find optimal solutions when choices depend on previous positions. 🎯 Core Idea Starting from the first row, the minimum cost to reach any cell depends on the minimum cost of reaching the three possible cells above it: directly above, diagonally left, or diagonally right. By building these minimum costs row by row, we ensure every decision is based on the best possible previous outcome. 🔍 Why This Problem Is Interesting It extends the idea of grid DP by allowing diagonal movement, which slightly increases the decision space but keeps the core DP principle intact. The challenge lies in handling boundaries while maintaining clean state transitions. 🧠 Key Insight Each cell represents the minimum cost to reach that position from the top. Once all rows are processed, the minimum value in the last row gives the answer - no backtracking required. ⏱ Time Complexity → O(n²) 🧠 Space Complexity → O(n) using optimized DP 🌱 Daily Learning Takeaway When each step depends only on a small local neighborhood, dynamic programming provides clarity and efficiency by reusing the best results from earlier steps. #leetcode #dsa #dynamicprogramming #coding #learningeveryday #growthmindset #developer #problemsolving

Day 8/100 of my #100DaysOfCode challenge! 🚀 Today's problem: "Minimum Falling Path Sum" - a dynamic programming challenge on LeetCode. 📌 The task: Given an n x n matrix, find the minimum sum of any falling path through the matrix, where from position (i, j) you can move to (i+1, j-1), (i+1, j), or (i+1, j+1). 💡 Key Insight: This is a classic dynamic programming problem where we build the solution row by row. For each cell in the current row, the minimum falling path sum is the cell's value plus the minimum of the three possible parent cells from the previous row. 🔧 Approach: Initialize the first row of DP table with the matrix's first row values For each subsequent row, compute each cell as its value plus the minimum of the three possible cells from the row above The answer is the minimum value in the last row ✅ Time Complexity: O(n²) ✅ Space Complexity: O(n²) (can be optimized to O(n) if needed) #LeetCode #DynamicProgramming #CodingChallenge #Algorithm #ProblemSolving #SoftwareEngineering #CareerGrowth #TechJourney

🚀 LeetCode Daily Practice – Day 34 Problem: Shortest Common Supersequence (Dynamic Programming) Today’s problem was about building the shortest string that contains two given strings as subsequences. At first, it feels like pure string merging — but the key idea connects directly to LCS. 🎯 Core Idea Instead of building the result directly, we first understand what both strings already share. The Longest Common Subsequence helps identify characters that don’t need to be duplicated. Once the LCS is known, we reconstruct the final answer by walking through both strings and inserting only what is necessary. This turns what looks like a hard construction problem into a structured DP walk. 🔍 Why This Problem Is Interesting It shows that sometimes the fastest way forward is by identifying overlap. By using LCS, we avoid redundant repetition and automatically get the shortest valid supersequence. 🧠 Key Insight Shortest Common Supersequence is built on top of Longest Common Subsequence. Understanding one unlocks the other — a great demonstration of how DP problems are often linked. ⏱ Time Complexity → O(m × n) 🧠 Space Complexity → O(m × n) 🌱 Daily Learning Takeaway Efficiency is not always about adding more — sometimes it’s about recognizing what you can reuse. #leetcode #dsa #dynamicprogramming #strings #coding #learningeveryday #growthmindset #developer #problemsolving

Leetcode Biweekly 172 - solved 𝟑/𝟒 problems. I started 𝟐𝟎 𝐦𝐢𝐧𝐮𝐭𝐞𝐬 𝐥𝐚𝐭𝐞 due to the server and network error, still manage to solve 3/4 problems 𝐰𝐢𝐭𝐡𝐢𝐧 𝟑𝟖 𝐦𝐢𝐧𝐮𝐭𝐞𝐬 after start. Here is my solution: 1️⃣ Create a map to count the frequency of each element and create a multiset to store the current highest frequency element. Now we will traverse our vector, since we have to remove the first 3 elements so at every i % 3 == 0, we will check if the highest frequency == 1 means all elements are distinct and we can break else increment ans and we will erase the current element's frequency from multiset, decrement it in the map, and reinsert its updated frequency into the multiset. 2️⃣ A cakewalk number theory problem for a CF solver. As we know, the sum of three elements will be divisible by 3 if sum of their modulo with 3 is divisible by 3. So, we need to create three vectors which store elements with modulo 0, 1, and 2 respectively and sort them in descending order, and try these combinations - three 0s, three 1s, three 2s, and one 0, one 1, and one 2 modulo element and take max of them as ans. 3️⃣ The main observation is that we can't move '1' towards the right and can only move it towards the left, so it will be optimal if '1' will be in front of the current largest number of the vector towards the left side. To keep track of it, we will use a priority queue(pq). We will traverse the string and push corresponding vector elements into the pq, and whenever we have '1' in the string, we will add the top element of the pq to ans and pop it. Although my yesterday Codeforces round was not gone well, but 𝐭𝐡𝐞 𝐛𝐞𝐬𝐭 𝐩𝐚𝐫𝐭 𝐚𝐛𝐨𝐮𝐭 𝐜𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐩𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 𝐢𝐬 𝐭𝐡𝐚𝐭 𝐞𝐯𝐞𝐫𝐲 𝐜𝐨𝐧𝐭𝐞𝐬𝐭 𝐠𝐢𝐯𝐞𝐬 𝐲𝐨𝐮 𝐚 𝐟𝐫𝐞𝐬𝐡 𝐬𝐭𝐚𝐫𝐭 𝐚𝐧𝐝 𝐚 𝐧𝐞𝐰 𝐜𝐡𝐚𝐧𝐜𝐞 𝐭𝐨 𝐜𝐨𝐦𝐞 𝐛𝐚𝐜𝐤. #coding #leetcode #competitiveprogramming

🚀 LeetCode Daily Practice – Day 30 Problem: Longest Palindromic Substring (Dynamic Programming) Today’s problem revisited palindromes, but this time with a pure DP perspective. Instead of expanding from centers, the focus was on building answers for smaller substrings and using them to solve larger ones. 🎯 Core Idea We use a DP table where each state represents whether a substring between two indices is a palindrome. A substring is palindromic if: – the characters at both ends match – the inner substring is already known to be a palindrome By filling the table based on substring length, we ensure smaller decisions are made before larger ones. 🔍 Why This Approach Is Interesting It shows how DP can model string problems using ranges rather than positions. The order of computation matters — shorter substrings must be solved first so longer ones can rely on correct information. 🧠 Key Insight Dynamic programming here is about state dependency. Once we know which inner substrings are palindromes, extending outward becomes a simple and reliable check. ⏱ Time Complexity → O(n²) 🧠 Space Complexity → O(n²) 🌱 Daily Learning Takeaway When problems involve overlapping ranges, DP provides a structured way to build global answers from local truths. #leetcode #dsa #dynamicprogramming #strings #coding #learningeveryday #growthmindset #developer #problemsolving

🚀 LeetCode Daily Practice – Day 28 Problem: Longest Palindromic Subsequence (Dynamic Programming) Today’s problem was a great reminder that symmetry can be hidden inside sequences. The goal is to find the longest subsequence that reads the same forward and backward, without requiring characters to be contiguous. 🎯 Core Idea We use DP to compare characters from both ends of the string. If the characters at the start and end match, they contribute to the palindromic subsequence. If they don’t, we explore the best result by skipping one character from either side. 🔍 Why This Problem Is Interesting It highlights how subsequences differ from substrings. Even when characters are far apart, DP allows us to reason about symmetry by breaking the string into smaller ranges. 🧠 Key Insight The problem can be viewed as finding the Longest Common Subsequence between the string and its reverse. This perspective helps connect multiple DP problems under the same pattern. ⏱ Time Complexity → O(n²) 🧠 Space Complexity → O(n²) or O(n) with optimization 🌱 Daily Learning Takeaway Symmetry doesn’t always appear next to itself — sometimes it reveals itself only when you compare the whole picture. #leetcode #dsa #dynamicprogramming #strings #coding #learningeveryday #growthmindset #developer #problemsolving

Solved a HARD Dynamic Programming problem on LeetCode 💥 .Today I worked on LeetCode 312 – Burst Balloons, one of the most challenging Interval DP problems. At first glance, the problem looks greedy — but every greedy approach fails. The real solution requires a different way of thinking: 👉 Instead of choosing which balloon to burst first, 👉 Think about which balloon is burst LAST in a given range. This shift in perspective unlocked the solution. Key learnings: Interval Dynamic Programming Optimal substructure in ranges Why brute force and greedy don’t work How reversing the decision simplifies the state Time Complexity: O(n³) Space Complexity: O(n²) Problems like this remind me that DP is not about memorizing formulas, but about learning how to think recursively with states. 🔗 Problem link: https://lnkd.in/gcHjprZw #DynamicProgramming #LeetCode #HardProblems #ProblemSolving #DSA #SoftwareEngineering #LearningJourney 😵💫