Optimized Climbing Stairs Solution with Dynamic Programming

🚀 Day 12 of My LeetCode Journey Today I solved Pow(x, n) (LeetCode 50). Problem: Implement a function to calculate x raised to the power n (xⁿ). The challenge is to handle large powers efficiently instead of multiplying x repeatedly. Approach: I used Binary Exponentiation (Fast Power). Key Idea: • If n is even → xⁿ = (xⁿ⁄²)² • If n is odd → xⁿ = x × xⁿ⁻¹ • If n is negative → convert to 1/x and make n positive This reduces the time complexity from O(n) to O(log n). Concepts Used: • Math • Binary Exponentiation • Iterative optimization Time Complexity: O(log n) Space Complexity: O(1) #leetcode #datastructures #algorithms #java #codinginterview #softwareengineering

Day 71 - LeetCode Journey Solved LeetCode 64: Minimum Path Sum (Medium) today — a classic grid-based dynamic programming problem. The challenge is to move from the top-left corner to the bottom-right corner of the grid while minimizing the sum of all numbers along the path. The only allowed moves are right or down, which makes this a perfect candidate for DP. 💡 Core Idea: Each cell represents the minimum cost required to reach that cell. To reach cell (i, j) we can come from: • Top → (i-1, j) • Left → (i, j-1) So the transition becomes: grid[i][j] += min(grid[i-1][j], grid[i][j-1]) By updating the grid in-place, we gradually build the minimum path cost for every cell until we reach the final destination. ⚡ Key Learning Points: • Applying Dynamic Programming on grids • Using in-place optimization to reduce space • Understanding state transition from top and left cells • Achieving O(m × n) time complexity Problems like this build strong foundations for many advanced DP questions involving paths, matrices, and grid traversal. ✅ Stronger understanding of grid DP ✅ Better optimization mindset ✅ Improved problem-solving patterns Step by step, the DSA journey continues 🚀 #LeetCode #DSA #Java #DynamicProgramming #GridDP #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

Day 70 - LeetCode Journey Solved LeetCode 88: Merge Sorted Array (Easy) today — a classic problem that focuses on array manipulation and the two-pointer technique. The challenge is to merge two sorted arrays into one sorted array without using extra space, by modifying nums1 in-place. 💡 Core Idea: Instead of merging from the beginning, we start from the end of the arrays. Why? Because nums1 already has extra space at the end to accommodate elements from nums2. We use three pointers: • i → last valid element in nums1 • j → last element in nums2 • k → last position of merged array At each step, we place the larger element at position k, ensuring the array remains sorted. ⚡ Key Learning Points: • Using the two-pointer technique from the end • Performing in-place array merging • Maintaining O(m + n) time complexity • Avoiding unnecessary extra space This problem is a great reminder that sometimes changing the direction of traversal makes the solution much simpler. ✅ Better understanding of array manipulation ✅ Stronger grasp of two-pointer techniques ✅ Improved problem-solving efficiency Small problems like this build strong fundamentals for bigger challenges 🚀 #LeetCode #DSA #Java #TwoPointers #Arrays #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

🚀 Day 525 of #750DaysOfCode 🚀 💡 LeetCode 1980: Find Unique Binary String Today’s problem was an interesting one involving binary strings and a clever observation. We are given n unique binary strings of length n, and the task is to return any binary string of length n that does not exist in the given array. 🔎 Approach I Used I applied a concept similar to Diagonalization. Traverse the array from 0 → n-1 Look at the i-th character of the i-th string Flip it (0 → 1 or 1 → 0) Append the flipped character to build a new string This guarantees the newly created string differs from every string in the list at least at one position, ensuring it is unique and not present in the array. ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(n) This approach works efficiently because the constraints are small and we only need to ensure one position difference with each string. Problems like this highlight how a simple observation can eliminate brute force completely. #leetcode #coding #programming #java #datastructures #algorithms #problemSolving #developer #codingchallenge #750DaysOfCode

🚀 Day 20 of LeetCode Challenge Today’s problem: Perfect Squares 🟩 🔹 Problem: Given a number n, find the minimum number of perfect square numbers (1, 4, 9, 16, …) whose sum equals n. 🔹 Examples: ✔ n = 12 → Output: 3 → (4 + 4 + 4) ✔ n = 13 → Output: 2 → (4 + 9) 🔹 Approach I used: Dynamic Programming Let m[i] store the minimum squares required to make sum i For every number, try subtracting perfect squares Choose the minimum count 🔹 Key Insight: This problem follows the same pattern as Coin Change (minimum coins). 🔹 Complexity: ⏱ Time → O(n√n) 📦 Space → O(n) 🔹 What I learned today: ✅ Identifying DP patterns in problems ✅ Breaking numbers using square combinations ✅ Optimizing from brute force to efficient DP Consistency > Motivation 💪 Learning one problem at a time! #Day20 #LeetCode #Java #DataStructures #DynamicProgramming #CodingJourney

🚀 LeetCode Problem Solved: Maximum Average Subarray I Day 14 of #75DaysofLeetCode Today I solved LeetCode 643 – Maximum Average Subarray I using the Sliding Window Technique. 🔹 Problem: Given an integer array nums and an integer k, find a contiguous subarray of length k that has the maximum average value. 🔹 Key Idea: Instead of recalculating the sum of every subarray of size k, we use the Sliding Window approach to update the sum efficiently by: • Adding the next element • Removing the previous element from the window This reduces the time complexity from O(n × k) to O(n). 💡 Concept Used: ✔ Sliding Window Algorithm ✔ Efficient Array Traversal ✔ Optimized Time Complexity 📌 Example: Input: nums = [1,12,-5,-6,50,3], k = 4 Output: 12.75 ✨ What I Learned: This problem helped me strengthen my understanding of window-based optimization techniques, which are very useful in many array and string problems. 🔗 Practicing data structures and algorithms consistently to improve problem-solving skills. #LeetCode #DSA #SlidingWindow #ProblemSolving #CodingPractice #Java #LearningInPublic #Programming

🚀 Day 535 of #750DaysOfCode 🚀 ✅ Solved: Count Submatrices with Top-Left Element and Sum ≤ k (LeetCode 3070) Today’s problem was a great example of using 2D Prefix Sum to optimize matrix queries. Instead of checking every possible submatrix, we can observe that the question only allows submatrices that include the top-left element (0,0). This means every valid submatrix is just a prefix rectangle, so we can compute the sum efficiently using prefix sums. 💡 Key Learning: Used 2D Prefix Sum technique Reduced brute force complexity to O(m × n) Learned how to handle matrix range sum problems efficiently 📌 Approach: Build prefix sum for each cell Check if sum from (0,0) to (i,j) ≤ k Count valid submatrices This problem improved my understanding of: ✔️ Prefix Sum ✔️ Matrix DP patterns ✔️ Optimization from brute force to efficient solution Consistency continues 🔥 On to Day 536 tomorrow. #leetcode #java #datastructures #algorithms #codingchallenge #prefixsum #matrix #programming #softwareengineering #750daysofcode

Day 57 - LeetCode Journey Solved LeetCode 2104: Sum of Subarray Ranges (Medium) today using a brute force + optimization approach. This journey isn’t about solving the hardest problems daily, but about showing up consistently and improving step by step. Problems like this help in building a deeper understanding of arrays and how subarrays behave. Today’s problem reinforced key concepts like: • Understanding how to generate all subarrays efficiently • Tracking minimum and maximum values dynamically • Avoiding recomputation using smart updates • Writing clean and logical nested loop solutions The idea is simple — for each starting index, expand the subarray and keep updating min and max to calculate the range 💡 Every problem adds a new layer to problem-solving skills, and that’s where real growth happens 💯 ✅ Better understanding of subarrays and ranges ✅ Improved thinking for optimization ✅ More confidence in array-based problems Still a long way to go, but progress is progress 🚀 #LeetCode #DSA #Java #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #Algorithms #Programming #DeveloperJourney #KeepCoding

🚀 Day 12 of My LeetCode Journey Today I solved Rotate Image (LeetCode 48). Problem: Given an n × n matrix representing an image, rotate the matrix by 90 degrees clockwise. The challenge is to perform the rotation in-place, without using another matrix. Approach: I used a simple two-step trick: 1️⃣ Transpose the matrix (swap rows and columns) 2️⃣ Reverse each row This combination effectively rotates the matrix by 90° clockwise. Time Complexity: O(n²) Space Complexity: O(1) Problems like this improve understanding of matrix manipulation and in-place transformations. #leetcode #datastructures #algorithms #java #codinginterview #softwareengineering

🚀 Daily LeetCode Challenge – Day 37 Today’s problem was Find All Possible Stable Binary Arrays I. Problem: We are given three integers zero, one, and limit. We need to count the number of stable binary arrays such that: The array contains exactly zero number of 0s. The array contains exactly one number of 1s. Any subarray with size greater than limit must contain both 0 and 1. In simpler terms, we cannot place more than limit consecutive 0s or 1s, otherwise the array becomes unstable. The brute force that came to mind: Generate all possible arrays using the given number of 0s and 1s and then check if they satisfy the limit condition. But this approach quickly becomes inefficient because the number of combinations grows rapidly. 💡 Better Idea – Dynamic Programming with Memoization First, we focus on the limit. The limit tells us the maximum number of identical elements that can appear consecutively. For example, if limit = 2, then sequences like [0,0,0] or [1,1,1] are not allowed because they contain more than two identical elements in a row, which would make the array unstable. To construct valid arrays, we add elements in blocks: ->If the last placed element was 1, the next block must contain 0s. ->If the last placed element was 0, the next block must contain 1s. ->The size of each block can range from 1 to min(remaining elements, limit). This ensures that: we never exceed the number of remaining 0s or 1s we never violate the limit constraint. We recursively explore all valid possibilities while keeping track of: ->remaining 0s ->remaining 1s ->the last placed element. To avoid recomputation, we store previously computed results in a DP table. ⚡ Time Complexity: O(zero × one × limit) ⚡ Space Complexity: O(zero × one) 🔍 Key Insight: Instead of generating all binary arrays, we construct them step by step while respecting the limit constraint and store intermediate results, which turns an exponential brute force solution into an efficient dynamic programming approach. #LeetCode #DailyCodingChallenge #Java #DynamicProgramming #Algorithms #ProblemSolving #CodingInterview