Min Stack with O(1) getMin

Min Stack: Parallel Stack Tracks Running Minimum in O(1) Tracking minimum naively requires O(n) scan on each getMin. Solution: maintain parallel stack where each position stores minimum of all elements at/below it. Push/pop update both stacks synchronously. getMin becomes O(1) lookup of minStack top. Auxiliary Stack Pattern: When needing O(1) access to aggregate property (min, max, sum) at any stack depth, maintain parallel stack tracking that property. Space doubles but all ops remain O(1). Time: O(1) all operations | Space: O(n) #Stack #AuxiliaryStructure #MinTracking #ConstantTime #Python #DataStructureDesign #SoftwareEngineering

🚀 Day 17 of #DSAStreak 📌 Problem: Longest Common Prefix 🧠 Problem Summary: Given an array of strings, find the longest common prefix shared among all strings. If no common prefix exists → return "" 💡 Approach: Vertical Scanning 🔥 Instead of comparing entire strings (slow ❌), we optimize using: ✔ Take first string as reference ✔ Compare characters index by index ✔ Check across all strings ✔ Stop immediately at first mismatch ⚙️ Key Logic: Take first string → iterate over each character Compare with same index in other strings If mismatch or index out of bound → return prefix till that point 📌 Example: Input: ["flower","flow","flight"] Output: "fl" Explanation: First mismatch at index 2 → "o" ≠ "i" ⏱ Time Complexity: O(N × M) 💾 Space Complexity: O(1) 🔥 Key Learnings: 👉 Nested loops ≠ always O(n²) 👉 Early stopping saves time 👉 Compare character-wise, not string-wise 👉 Prefix must be common in ALL strings #Python #DSA #Strings #CodingJourney #100DaysOfCode #ProblemSolving #LeetCode #Tech

LCA of BST: Exploiting Order Property for O(1) Space Generic tree LCA needs full traversal. BST ordering enables iterative solution — LCA is where paths diverge. Both values smaller? Go left. Both larger? Go right. Otherwise, current node is split point = LCA. BST Advantage: Ordering enables O(h) iterative solution without recursion stack. Divergence point is guaranteed LCA by BST property. This demonstrates how data structure properties simplify algorithms. Time: O(h) | Space: O(1) #BST #LCA #OrderProperty #IterativeSearch #Python #AlgorithmDesign #SoftwareEngineering

📌 Problem: Product of Array Except Self 💡 Approach: Instead of using division, compute the result using prefix and suffix products. First, traverse from left to right to store prefix products in the result array. Then, traverse from right to left to multiply with suffix products. This ensures each index contains the product of all elements except itself. ⚙️ Key Insight: Avoid division to handle zero cases efficiently Use prefix and suffix multiplication in a single result array Optimized space usage (no extra arrays needed) ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) (excluding output array) 📚 What I learned: Prefix & suffix technique for array problems Space optimization strategies #LeetCode #DSA #Algorithms #Coding #ProblemSolving #Python #InterviewPreparation #Array #CodingJourney

LeetCode Problem 155 "Min Stack": Design a stack that supports push, pop, top, and retrieving the minimum element in constant time. Implement the MinStack class: MinStack() initializes the stack object. void push(int val) pushes the element val onto the stack. void pop() removes the element on the top of the stack. int top() gets the top element of the stack. int getMin() retrieves the minimum element in the stack. You must implement a solution with O(1) time complexity for each function. Approach: we can implement a single stack and store values as tuples (current element, min so far). But wait ... consider edge case when we pop and the stack becomes empty, so to handle this we consider two conditions- one when stack becomes empty, we set min so far to +ve infinity again, second whenever we pop elements, if stack is not empty, we update min so far to the top of the stack's min so far. In this way we can keep track of the minimum element upto a specific stack level. Time complexity of all the operations: O(1) #Python #LeetCode #ProblemSolving #DSA #InterviewPrep #DataStructures #Algorithms #Programming

Valid Sudoku: Single-Pass Validation with Three HashSets Checking rows, columns, and 3×3 boxes separately requires multiple passes. Single-pass optimization: maintain HashSets for each constraint simultaneously. For each cell, verify value doesn't exist in its row, column, or box. Box index calculated via integer division. Box Index Trick: (r // 3, c // 3) maps cells to 3×3 box coordinates. This division-based indexing elegantly handles spatial grouping without explicit boundary checks. Time: O(1) — fixed 81 cells | Space: O(1) — fixed constraints #Sudoku #HashSet #SinglePassValidation #SpatialIndexing #Python #AlgorithmDesign #SoftwareEngineering

Two Sum II: Sorted Input Enables O(1) Space Solution HashMap two-sum costs O(n) space. When input is sorted, two pointers from opposite ends eliminate extra space. Current sum too large? Move right pointer left (smaller values). Too small? Move left pointer right (larger values). Sorted Data Advantage: Pre-existing order enables space-efficient algorithms. Leveraging structure (sorted arrays, BST properties, monotonic stacks) transforms O(n) space solutions to O(1). Time: O(n) | Space: O(1) #TwoPointers #SortedArrays #SpaceOptimization #TwoSum #Python #AlgorithmDesign #SoftwareEngineering

LeetCode 200. Number of Islands: "Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water." Approach: Using Depth-first-search, traverse the grid, if '1' is encountered, mark is '0' and explore its 4-side neighbors, for this create a function that recursively explores the neighbors forming an island of '1'. Count the number of islands formed. time complexity: O(N*M) #Python #LeetCode #DSA #CompetitiveProgramming #Graphs #OptimalSolution

Daily Temperatures: Monotonic Stack for Next Warmer Day Checking future temperatures for each day is O(n²). Monotonic decreasing stack reduces to O(n) — stack holds indices waiting for warmer days. When warmer temperature arrives, resolve all waiting cooler temperatures via stack pops. Monotonic Stack: Elements waiting for "next greater/smaller" use monotonic stacks. Each element pushed/popped once = amortized O(n). Pattern appears in stock span, histogram area, next greater problems. Time: O(n) amortized | Space: O(n) #MonotonicStack #NextGreaterElement #AmortizedAnalysis #StackOptimization #Python #AlgorithmDesign #SoftwareEngineering

Efficient grid navigation often requires a clear understanding of how different components or "tiles" connect to one another. A common challenge in pathfinding is determining if a continuous route exists from a starting point to a destination based on specific connection rules for each cell. In this approach, I utilized a transition table to map how an incoming direction (Top, Right, Bottom, Left) translates to an outgoing direction based on the tile type. By defining these movements as a fixed set of rules, the algorithm can traverse the grid in constant space, O(1), excluding the input itself. The logic follows a simple "follow the pipe" strategy: Start from the initial cell and check both possible exit directions. Update the current position based on the permitted transition. If the next cell does not support the incoming direction, the path is invalid. The process continues until the target coordinates are reached or the path breaks. This method ensures high performance by avoiding complex recursion or auxiliary data structures while maintaining strict adherence to the grid's connectivity constraints. #Algorithms #Python #CodingEfficiency #ProblemSolving #DataStructures