Maximizing Spanning Tree Stability with LeetCode Challenge

When I’m solving problems on LeetCode, I usually hit a wall—not because I don't understand the logic, but because I struggle to recall the exact template or pattern for specific categories. While Binary Search is straightforward, I found myself constantly falling short on Graphs, Backtracking, and Dynamic Programming. It gets even trickier when a problem requires layering multiple patterns to get that optimized solution. To help myself, I started documenting at-a-glance patterns and templates. I realized this could help others who are stuck in the same "grind" as me, so I put everything together into a central hub called AlgoSheet. Check it out here: https://lnkd.in/gCNPzDwj It’s currently a GitHub page where I’ve compiled the most frequent patterns. It's built by a dev, for devs. If you find it useful, feel free to use it for your interview prep. I’m also totally open to suggestions or PRs if you want to help expand the pattern library! #LeetCode #CodingInterview #SoftwareEngineering #DSA #AlgoSheet

Day 71 on LeetCode Find Peak Element ⛰️✅ Today’s problem introduced a Binary Search approach, but I first solved it using a brute-force traversal to build intuition. 🔹 Approach Used in My Solution (Brute Force) The goal was to find an element that is greater than its neighbors. Key idea: • Traverse the array from index 1 to n-1 • Check if current element is greater than its neighbors • Handle edge cases like last element separately • Return the index once a peak is found This approach is simple and works reliably. 🔹 Optimized Approach (Binary Search Insight) • If nums[mid] < nums[mid+1] → peak lies on the right side • Else → peak lies on the left side (including mid) • Continue narrowing until left == right ⚡ Complexity: • Brute Force: O(n) • Binary Search: O(log n) 💡 Key Takeaways: • Building intuition with brute force helps understand the problem deeply • Learned how to transition from linear scan → binary search optimization • Reinforced that multiple approaches can lead to the same result, but efficiency matters 🔥 Step by step, moving from basic logic to optimized patterns! #LeetCode #DSA #Algorithms #DataStructures #BinarySearch #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

I just completed 100 problems on LeetCode — but the real value is in how my thinking evolved. When I started, I struggled with basic syntax, debugging errors, and even simple problems felt overwhelming. Instead of rushing through questions, I focused on building a strong foundation step by step. Here’s how my journey progressed: 🔹 Data Structures I worked on: • Arrays • Strings • Linked Lists • Stack • HashMap 🔹 Problem-Solving Patterns I learned : • Brute Force → understanding the problem • Two Pointer technique • Sliding Window (fixed & variable) • Hashing / Frequency Maps • Prefix Sum • Slow & Fast Pointer • Stack-based problems • Monotonic Stack • Greedy Algorithms 🔹 Key Improvements: • Reduced silly mistakes (index errors, edge cases) • Better debugging and cleaner code • Shifted from “what to do” → “why it works” 📊 Stats: • 100 problems solved • 55 Easy | 41 Medium | 4 Hard • 70%+ acceptance rate 💡 Biggest realization: DSA is not about solving more problems — it’s about recognizing patterns and applying them efficiently. 🚀 Next Goals: • Solve more Medium & Hard problems • Improve speed and consistency • Prepare for real coding interviews If you're starting your DSA journey: Don’t focus on speed. Focus on understanding. Speed comes later. #leetcode #dsa #coding #programming #softwareengineering #learning

I used to solve subarray problems in O(n²)… and thought that was normal. Until I discovered one simple idea that changed everything: 👉 Prefix Sum (Also — this post is a bit delayed, but the learning didn’t stop ⚡) Hello everyone 👋 This is Week 3 of my DSA Pattern Revision And honestly… this week felt like a breakthrough. 🔍 What changed? Earlier, every subarray problem felt like: 👉 Try all subarrays → check condition → TLE 😓 Now, I approach them like: 👉 Precompute smartly → reuse → solve in O(n) 🚀 ⚡ The Game-Changing Patterns I Learned 🔹 Prefix Sum (1D & 2D) Instead of recalculating sums again and again, I now store cumulative results once and reuse them. 👉 Suddenly: -Range sum → O(1) -Subarray problems → Much faster 🔹 Prefix Sum + Hashing (Most Powerful) This was the real unlock 🔓 👉 Idea: If two prefix sums differ by k, there exists a subarray with sum k. This single observation solves: -Subarray Sum Equals K -Largest Subarray with 0 Sum -Count Subarrays Divisible by K 🔹 Difference Array At first, it felt counterintuitive… But then it clicked 🤯 👉 Instead of updating every element in a range, just update the boundaries and reconstruct later. Massive optimization for range update problems. 🔹 Prefix Sum + Sliding Window When problems mix constraints like: 👉 fixed sum + variable window Combining patterns becomes the key. 🧠 Biggest Realization This Week It’s not about learning more problems. It’s about seeing the same problem differently. 💡 The Shift in Thinking Before: “Which problem is this?” Now: “Which pattern fits here?” 🚀 GitHub Repository I’ve implemented all problems with explanations in C++: 🔗 https://lnkd.in/gCMuX_zX If you’re preparing for coding interviews, Prefix Sum is not optional — it’s essential. #DSA #Algorithms #PrefixSum #CodingInterview #ProblemSolving #LeetCode #A2Z #Consistency

This problem really tested my understanding of backtracking. 🚀 **Recursion Series — Day 10/10** Today’s problem: 📌 Word Search 🔗 https://lnkd.in/gKhxV-7t --- ### 💡 My approach The idea was simple but tricky to implement: 👉 Try to find the word starting from every cell 👉 Move in 4 directions (up, down, left, right) 👉 Match characters step by step So basically: • If current cell matches the character → explore further • If not → stop that path --- ### 🔁 How I handled it I used **backtracking (DFS)**: • Mark the current cell as visited (by replacing it temporarily) • Explore all 4 directions • Restore the cell after recursion (backtrack) This ensures: 👉 No cell is reused in the same path 👉 All possible paths are explored --- ### 🧠 Intuition Think of it like: 👉 Starting from a cell and trying to “walk” through the grid to form the word At every step: • You have 4 choices (directions) • You continue only if characters match If any path successfully forms the word → return true --- ### ⏱ Complexity (my understanding) Let: m = number of rows n = number of columns k = length of word Time: O(m × n × 4^k) (For each cell, we explore up to 4 directions recursively) Space: O(k) (Recursion depth = length of word) --- ### 💭 What I learned Backtracking is not just about recursion — it’s about **exploring paths and undoing choices carefully**. One small mistake in marking/unmarking can break the entire logic. --- 10 days of recursion done ✅ Still a lot to learn… but definitely more confident now. #Recursion #Backtracking #DSA #LeetCode #ProblemSolving #CodingJourney #Consistency #LearningInPublic

Hii ✨ 🚀 Day 4 / 150 — Top Interview Questions Journey Solved Remove Duplicates from Sorted Array II on LeetCode today. This problem looked simple… but the logic twist was powerful. 🧩 Problem Summary Given a sorted array, allow each element to appear at most twice. Do it in-place with O(1) extra space and keep the order. 💡 Key Insight (The Trick) The magic line: if k < 2 or nums[i] != nums[k-2]: k < 2 → First two elements can always be kept nums[i] != nums[k-2] → Check if this number is already kept twice This k-2 idea was the real brain exercise today . 🧠 I Learned DSA is not about coding fast It’s about dry run + pattern thinking Understanding why we use k-2 instead of k-1 Two pointers pattern becomes clearer with practice. 📌 Takeaway Struggled a lot to understand the logic… but once it clicked, it felt amazing. Consistency is more important than speed in DSA learning. #Leetcode #DSAPython

Day 93 of #365DaysOfLeetCode Challenge Today’s focus: **Sharpening problem-solving patterns & consistency** Not every day is about solving the hardest problem — some days are about **strengthening fundamentals and recognizing patterns faster**. 💡 **What I focused on today:** * Revisiting previously solved problems * Improving solution efficiency * Understanding *why* an approach works, not just *how* * Practicing edge cases and optimization thinking 📌 **Key Takeaway:** Growth in DSA isn’t just about solving new problems — it’s about: * Building intuition * Reducing solution time * Writing cleaner and more optimized code ⚡ Small improvements daily → Big results over time **What I learned today:** Consistency compounds. The more problems I revisit and refine, the more natural patterns like sliding window, prefix sums, and math-based grouping become. #LeetCode #DSA #CodingChallenge #ProblemSolving #Consistency #TechJourney

📌 Strengthening DSA Concepts through Problem Solving Recently, I worked on LeetCode 525 – Contiguous Array At first glance, it looks like a simple array problem… but the real challenge? Converting it into a prefix sum problem and spotting patterns 🔍 Problem You’re given: 👉 nums → a binary array (only 0s and 1s) Your task: 👉 Find the maximum length of a contiguous subarray with equal number of 0s and 1s 🧠 Naive Thinking → Generate all subarrays → Count 0s and 1s in each But this leads to: ❌ Time complexity ~ O(n²) ❌ Not efficient for large inputs 💡 Optimized Approach (Prefix Sum + HashMap) 👉 Convert the problem cleverly: Treat 0 as -1 Treat 1 as +1 Now the problem becomes: 👉 Find the longest subarray with sum = 0 🔑 Key Idea 1️⃣ Maintain a running sum 2️⃣ Store the first occurrence of each sum in a HashMap 3️⃣ If the same sum appears again → subarray in between has sum = 0 4️⃣ Track the maximum length 👉 Why first occurrence? Because it gives the longest possible subarray ⚙️ Core Logic 👉 If sum is seen before at index j 👉 Current index is i Then: 👉 subarray length = i - j 🚀 Why this works 👉 Equal 0s and 1s cancel each other out 👉 Same prefix sum means net effect is zero 👉 Efficiently avoids recomputation ⏱️ Complexity 👉 Time Complexity: O(n) 👉 Space Complexity: O(n) #DSA #PrefixSum #HashMap #LeetCode #ProblemSolving #CodingInterview #100DaysOfCode

Day 1: LeetCode - 35. Search Insert Position Starting my DSA journey with a classic binary search problem. Sometimes the goal isn’t just to find an element, but to figure out where it belongs. The Key Insight: If the target is not present, the correct insert position is exactly where the binary search ends — the low pointer naturally points to that position. My Approach: Apply binary search on the sorted array Compare mid with target and adjust search space If not found, return low as the insert index Takeaway: Binary search is more than searching — it helps solve positioning problems efficiently. Time Complexity: O(log N) | Space Complexity: O(1) Day 1 completed. #DSA #BinarySearch #LeetCode #CodingJourney

🚀 Day 13 of 100 Days LeetCode Challenge Problem: Minimum Number of Seconds to Make Mountain Height Zero Today’s problem was a strong mix of Binary Search + Mathematical Optimization 🔥 💡 Key Insight: Each worker takes time in an increasing pattern: For x units of work → time = t * (1 + 2 + ... + x) = t * x(x+1)/2 👉 This converts the problem into: “Given time T, how much total work can all workers complete?” 🔍 Core Approach: 1️⃣ Binary Search on Time (Answer) Guess a time T Check if all workers together can reduce height ≥ mountainHeight 2️⃣ For Each Worker: Solve: t * x(x+1)/2 ≤ T Find maximum x using math / binary search 3️⃣ Sum all x values If total ≥ required height → ✅ possible 🔥 What I Learned Today: Converting real-world problems into mathematical formulas is powerful Binary Search is not just for arrays—it works on answers too Combining math + search = efficient solution 📈 Challenge Progress: Day 13/100 ✅ Getting stronger every day! LeetCode, Binary Search, Mathematical Optimization, Greedy, Algorithms, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #BinarySearch #Mathematics #Optimization #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep