Optimizing LeetCode 62 with Dynamic Programming

Binary tree right side view Approach: - Keep a level variable - If level == result.size(), add current node (first node of that level) - Traverse right first, then left Time: O(n) Space: O(h) (worst: O(n), best: O(log n)) #Algorithms #DSA #LeetCode #coding #Programming

LCA - Lowest Common Ancestor of binary tree Approach: If current node is null, return null If current node is p or q, return current node Recursively search left and right If both sides return non-null → current node is LCA Otherwise → return the non-null side TC = O(n) SC = O(h) - depends on tree height (recursion stack) O(logn) - balanced tree O(n) - skewed tree #dsa #leetcode #consistency #coding #programming

In LeetCode 867 – Transpose Matrix Today I worked on a basic but important matrix problem: transposing a matrix. The idea is simple — convert rows into columns. Understanding matrix traversal helps build a strong foundation for more complex problems. #LeetCode #DSA #Coding #Programming #ProblemSolving #100DaysOfCode #DeveloperJourney #CodeNewbie #Tech #Learning #CodingLife #ComputerScience #Algorithms #Matrix #Consistency

49 of #100DaysOfCode Solved Next Greater Element II (LeetCode 503) using a Monotonic Stack + Circular Traversal approach 🔁 💡 Approach: Since the array is circular, we iterate 2 × n times to simulate wrapping around. Use a stack to store indices whose next greater element hasn’t been found yet. Traverse from left to right: If the current element is greater than the element at the index on top of the stack → update result. Keep popping until the stack condition breaks. Only push indices during the first pass (i < n) to avoid duplicates. ⚡ Key Insight: Using a monotonic decreasing stack helps us efficiently track elements waiting for their next greater value — reducing unnecessary comparisons. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(n) #LeetCode #DSA #Coding #Cpp #Programming #Stack #InterviewPrep

55 of #100DaysOfCode: Today I dived into LeetCode 316 (Remove Duplicate Letters). This problem is a fantastic lesson in balancing multiple constraints: maintaining unique characters while ensuring the smallest lexicographical order. The Key Insight: Using a Monotonic Stack approach. The goal isn't just to remove duplicates, but to greedily decide whether to keep a character or pop it based on whether it appears again later in the string. Stack Logic: Pop elements only if they are larger than the current character AND guaranteed to appear later. #cpp #leetcode #programming #algorithms #datastructures #codingcommunity #100daysofcode

51 of #100DaysOfCode Solved LeetCode 739 — Daily Temperatures using the Monotonic Stack approach 🔥 💡 Approach: Instead of checking every future day (which would be inefficient), I used a stack to store indices of temperatures in decreasing order. Traverse the array If the current temperature is higher than the one at the stack’s top, we’ve found the next warmer day Pop the index and calculate the difference Push the current index into the stack This ensures each element is processed only once — making it super efficient ⚡ ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) #leetcode #coding #dsa #cpp #programming #developers #tech #interviewprep

Flatten Binary tree to linked list Approach: Do kind of post-order traversal ( right -> left -> root ) maintain a previous node go right (recursively) go left (recursively) make root->right point to previous and root->left point to null and update previous to root TC: O(N) SC: O(N) - recursive stack #DSA #programming #coding #buildinpublic #Technology #ProblemSolving #LeetCode #LearnInPublic  #Consistency

DAY->26 🚀 LeetCode 1002 — Find Common Characters | Frequency Optimization 🔥 Solved this problem using a frequency array approach and achieved 100% runtime (0 ms) ⚡ 🔍 The goal is to find characters that appear in all strings, including duplicates. 💡 Approach: Use a frequency array of size 26 Initialize with a large value (INT_MAX) For each word: Count character frequency Update global frequency using minimum values 🧠 Key Insight: We take the minimum frequency because a character must exist in every string. ⚡ Complexity: Time → O(n × k) Space → O(1) This problem helped me understand how frequency comparison can efficiently find common elements 🚀 #DSA #LeetCode #Cpp #Coding #ProblemSolving #Arrays #LearningJourney

Recover the Tree ?? by providing water! Approach (Recover BST) Do inorder traversal (BST should be sorted) Track previous node If order breaks (prev > current), it’s a violation First violation: first = prev middle = current Second violation (if exists): last = current Time Complexity: O(n) → you traverse all nodes once using inorder Space Complexity: O(h) → recursion stack (h = height of tree) Worst case (skewed tree): O(n) Best case (balanced tree): O(log n) #LeetCode #DSA #DataStructures #Algorithms #Coding #Programming #binarysearchtree

Cycle Sort is not just another sorting algorithm, it is provably impossible to do fewer writes. Period. Cycle Sort follows where each element belongs, places it, picks up the displaced one, and follows that element. It continues chain after chain until every cycle closes. This is group theory disguised as a sorting algorithm. By minimizing writes to memory, Cycle Sort achieves the theoretical lower bound, making it optimal for scenarios where write operations are expensive, such as flash memory or EEPROM storage. Every element moves directly to its final position with no unnecessary swaps, proving that sometimes the most elegant solution is also the most mathematically efficient. #CycleSort #Programming #CodingLife #TechEducation #Algorithms #SortingAlgorithm #GroupTheory #OptimalAlgorithm #MemoryEfficient #ComputerScience #WriteOptimized #AlgorithmDesign #Coding #Developer #TechLearning #DataStructures #ProgrammingLife #CodeSmart #AlgorithmArt #ProvablyOptimal