Longest Increasing Path in a Matrix LeetCode Challenge

Today I solved LeetCode 543 – Diameter of Binary Tree. 🧩 Problem Summary: Given the root of a binary tree, return the diameter of the tree. The diameter is defined as the length of the longest path between any two nodes in the tree. This path may or may not pass through the root. 💡 Key Concepts Used: Binary Trees Recursion Depth First Search (DFS) Height calculation 🧠 Approach: Use DFS to calculate the height of each subtree. For every node: Compute left subtree height Compute right subtree height The diameter at that node = left height + right height Keep track of the maximum diameter seen so far. Return the height of the current node: 1 + max(left height, right height) ⏱ Time Complexity: O(N) — Each node is visited once. 📚 What I Learned: How to compute multiple values (height + diameter) in one traversal. Understanding that diameter doesn’t always pass through root. Optimizing recursive tree problems. Strengthening DFS and recursion concepts. Tree problems are sharpening my problem-solving skills Consistency and daily practice make the difference #LeetCode #DSA #BinaryTree #DiameterOfBinaryTree #DFS #Recursion #Java #CodingJourney #ProblemSolving #100DaysOfCode #TechGrowth

Day 70 of My DSA Journey Problem: Linked List Cycle (LeetCode 141) Today’s problem was all about detecting whether a linked list contains a cycle — a classic and very important concept in data structures. Key Idea: Floyd’s Cycle Detection Algorithm (Tortoise & Hare) Instead of using extra memory, we use two pointers: • Slow pointer → moves 1 step • Fast pointer → moves 2 steps If there’s a cycle, these two pointers will eventually meet. If not, the fast pointer will reach the end (null). Insight: This approach is efficient because it avoids using extra space like a HashSet and still guarantees detection in linear time. Complexity: • Time: O(n) • Space: O(1) What I learned: Sometimes, the smartest solutions don’t require extra space — just a clever observation and pointer manipulation! Consistency > Perfection 💯 On to Day 71 🚀 #DSA #100DaysOfCode #Java #CodingJourney #ProblemSolving #LinkedList

Day 50/75 — Climbing Stairs Today’s problem was a classic dynamic programming question — counting the number of distinct ways to reach the top. Approach: • Recognize it as a Fibonacci pattern • Each step = sum of previous two steps • Optimize space using two variables instead of an array Key logic: int current = prev1 + prev2; prev2 = prev1; prev1 = current; Time Complexity: O(n) Space Complexity: O(1) A fundamental problem that builds strong intuition for DP and recurrence relations. Halfway there — consistency paying off 🔥 50/75 🚀 #Day50 #DSA #DynamicProgramming #Java #Algorithms #LeetCode

“Most people try to overcomplicate this one… but the simplest approach wins.” Day 69 — LeetCode Progress Problem: Height Checker Required: Given an array of student heights, return the number of indices where the heights are not in the expected non-decreasing order. Idea: If we sort the array, we get the expected order. Now just compare the original array with the sorted version — mismatches are the answer. Approach: Create a copy of the original array Sort the copied array Traverse both arrays: Compare elements at each index If they differ → increment count Return the count Time Complexity: O(n log n) Space Complexity: O(n) #LeetCode #DSA #Java #Arrays #Sorting #ProblemSolving #CodingJourney

🚀 LeetCode Challenge 18/50 💡 Approach: Space-Optimized Dynamic Programming Recursion without memoization gives O(2ⁿ) — exponential! A full DP array gives O(n) space. But here's the trick: at every house we only ever look back TWO steps. So why store the entire array? 🔍 Key Insight: → At each house: either ROB it (prev2 + current) or SKIP it (prev1) → Take the maximum of both choices → Slide two variables forward — that's all we need! → No array, no extra memory 📈 Complexity: ❌ Brute Force → O(2ⁿ) Time ❌ DP Array → O(n) Time, O(n) Space ✅ Space-Optimized DP → O(n) Time, O(1) Space The best code isn't just correct — it's efficient. Sometimes the smartest move is knowing what NOT to store! 🧠 #LeetCode #DSA #DynamicProgramming #Java #ADA #PBL2 #LeetCodeChallenge #Day18of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #HouseRobber

✅ Solved LeetCode 217 — Contains Duplicate! Given an integer array nums, return true if any value appears at least twice. 🧠 My Approach: Sort + Linear Scan → Sort the array → adjacent duplicates are guaranteed to be neighbors → One pass to check if nums[i] == nums[i-1] → Time: O(n log n) | Space: O(1) 💡 Key Insight: Sorting brings duplicates side by side — no need for extra space like a HashSet. Trade time for space! ```java Arrays.sort(nums); for (int i = 1; i < nums.length; i++) { if (nums[i] == nums[i - 1]) return true; } return false; ``` 🔄 Alternative approaches: • HashSet → O(n) time, O(n) space • Brute force → O(n²) time (avoid!) Every problem teaches you a new trade-off. Keep grinding! 💪 #LeetCode #DSA #CodingInterview #Java #ProblemSolving #SoftwareEngineering #100DaysOfCode #Programming

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

Solved the Binary Tree Level Order Traversal problem using a BFS (Queue) approach. The idea is to traverse the tree level by level using a queue. For each level, we process all nodes currently in the queue and add their children for the next level. This ensures nodes are grouped level-wise in the result. Time Complexity: O(n) Space Complexity: O(n) #Java #DSA #Tree #BFS #LeetCode #Coding

🚀 LeetCode Challenge 16/50 💡 Approach: Dynamic Programming (Bottom-Up) A pure recursion approach explodes to O(2ⁿ) — exponential! By storing subproblem results in a DP array, we decode the entire string in a single linear pass. 🔍 Key Insight: → dp[i] = number of ways to decode first i characters → Single digit (1-9): dp[i] += dp[i-1] → Two digits (10-26): dp[i] += dp[i-2] → '0' alone is always invalid — handle carefully! → Build up the answer from base cases 📈 Complexity: ❌ Recursion (no memo) → O(2ⁿ) Time ✅ Dynamic Programming → O(n) Time, O(n) Space 🚀 Optimized DP → O(n) Time, O(1) Space (only 2 variables needed!) DP is not just an algorithm — it's a mindset. Break the problem, store the result, build the solution! 🧩 #LeetCode #DSA #DynamicProgramming #Java #ADA #PBL2 #LeetCodeChallenge #Day16of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #DecodeWays

Today I solved LeetCode 110 – Balanced Binary Tree. 🧩 Problem Summary: Given the root of a binary tree, determine if it is height-balanced. A binary tree is balanced if: The height difference between the left and right subtree of every node is not more than 1. 💡 Key Concepts Used: Binary Trees Recursion Depth First Search (DFS) Height calculation 🧠 Approach: Use DFS to calculate the height of each subtree. For every node: Get height of left subtree Get height of right subtree Check if the absolute difference is greater than 1: If yes → tree is not balanced Optimize by returning -1 early when imbalance is found to avoid unnecessary calculations. ⏱ Time Complexity: O(N) — Each node is visited once. 📚 What I Learned: Combining height calculation with validation in one traversal. Optimizing recursive solutions with early stopping. Understanding balanced vs unbalanced trees. Strengthening DFS and recursion skills. Improving step by step with tree problems Consistency is building confidence every day #LeetCode #DSA #BinaryTree #BalancedTree #DFS #Recursion #Java #CodingJourney #ProblemSolving #100DaysOfCode #TechGrowth