Solved LeetCode Problem #22: Generate Parentheses with Backtracking and Recursion

🚀 How I Solved LeetCode’s Word Search Problem Without DFS or Recursion When I came across Word Search (LeetCode 79), I noticed that almost every solution used DFS and backtracking. But I wanted to solve it my own way — using index tracking and adjacency logic instead of recursion. My intuition was simple: If a word exists in the grid, every next letter must lie right next to the previous one — either up, down, left, or right. That means their coordinate difference should satisfy: abs(x1 - x2) + abs(y1 - y2) == 1. This small observation became the foundation of my entire approach. 💡 My Thought Process 1️⃣ I mapped every letter in the grid to its coordinates. 2️⃣ I started from all positions of the first letter in the word. 3️⃣ For every next letter, I checked which positions are adjacent and not already used. 4️⃣ I extended paths step by step — no recursion, only iteration. 5️⃣ If any path reached the last letter → the word exists. ⚙️ My Implementation I used a BFS-style iterative search, where each state holds: the current cell (x, y) the current index in the word and a bitmask representing already-used cells. This replaced recursion and heavy visited[][][] arrays with a compact integer mask. Each move just extended to adjacent cells if the next character matched. It handled tricky cases like "ABCB" perfectly → returned false, which even some DFS implementations fail on. ✅ Why It Worked ✔️ No recursion = no stack overflow. ✔️ Bitmask = minimal memory use. ✔️ Adjacency rule = exactly matches grid movement. ✔️ Iterative BFS = simple, efficient, and logical. 🎯 What I Learned You don’t always need to follow the standard algorithms. Sometimes, just trusting your intuition and building around your idea leads to something even better. This problem taught me that creativity and logic go hand in hand. And when you believe in your approach — it truly works. 💪 #Coding #LeetCode #ProblemSolving #Cplusplus #Innovation #DSA #Learning #DeveloperJourney

🚀 #Day11 of #30DaysOfDSAChallenge 🚀 🎯 Topic: Infix ↔ Postfix / Prefix Conversion using Stack 💻 Today was all about turning logic into structure — converting expressions using the Stack data structure! 🧠 It’s amazing how a simple stack can manage complex operator precedence and parentheses so efficiently 🔥 💡 What I Explored: 🔹 Infix ➡️ Operators between operands → A + B 🔹 Postfix ➡️ Operators after operands → AB+ 🔹 Prefix ➡️ Operators before operands → +AB Code link 🖇️ https://lnkd.in/g3Py5xNi ✨ Why It’s Important: Understanding expression conversion is key in compiler design, expression evaluation, and even calculator algorithms 🧩 Each day, I’m not just learning syntax — I’m learning how computers think, process, and solve problems logically ⚙️💪 One more step closer to mastering Data Structures & Algorithms 🌟 #Day11 #30DaysOfDSAChallenge #DSA #Stack #CProgramming #InfixToPostfix #InfixToPrefix #ExpressionConversion #ProblemSolving #LearnToCode #CodingJourney #TechLearner #ProgrammersLife #DeveloperMindset #CodeEveryday #100DaysOfCode #CodingCommunity #Consistency #Motivation #CodeWithSiddhant #DataStructures #FutureEngineer

🚀 Day 52 of LeetCode 150 Days Challenge — Valid Parentheses #Day52 #LeetCode150 #CodingChallenge #DSA #Stack #Cplusplus #LeetCode #150DaysOfCode #CodeEveryday #LearnToCode #ProblemSolving #SoftwareEngineering #SDEPreparation #InterviewPrep 🧩 Problem Statement Given a string s containing only the characters '(', ')', '{', '}', '[', and ']', determine if the input string is valid. 👉 A string is valid if: Open brackets are closed by the same type of brackets. Brackets are closed in the correct order. ⚙️ Intuition This problem is about balancing parentheses — every opening bracket must have a matching closing one in order. A stack is perfect here since it follows LIFO (Last-In-First-Out) order: Push opening brackets onto the stack. When a closing bracket appears, check if it matches the top of the stack. If it matches → pop it. If not → invalid. At the end, if the stack is empty → it’s valid. 🧠 Example Dry Run Input: s = "{[()]}" Process: { → push [ → push ( → push ) → matches ( → pop ] → matches [ → pop } → matches { → pop Stack is empty → ✅ Valid ⏱ Complexity Analysis Time: O(n) — one pass through string Space: O(n) — for the stack 🌱 Takeaway This problem reinforces: Stack fundamentals Parentheses matching logic Edge case handling (unbalanced or extra closing brackets)

🚀 LeetCode Daily Challenge – Problem 81: Search in Rotated Sorted Array II Today I solved an interesting problem that tests both binary search optimization and edge case handling in rotated arrays. 🔍 Problem Summary: We’re given a rotated sorted array (which may contain duplicates) and need to determine whether a given target exists in it. 💡 Approach: Use a modified binary search to handle the rotation and duplicate values. If the middle element matches the target, return true. When duplicates are present (nums[low] == nums[mid] == nums[high]), adjust both ends to skip redundancy. Determine which side (left or right) is properly sorted and move the search boundaries accordingly. Continue until the target is found or the range is exhausted #LeetCode #DSA #CodingJourney #BinarySearch #ProblemSolving #CPlusPlus #StriversDSASheet ---

🚀 LeetCode Challenge Complete! Just solved "Increment Submatrices by One" - a perfect demonstration of the difference array technique for efficient range updates! 💡 Solution Approach: ✅ Phase 1 - Mark boundaries: For each query, add +1 at start column, -1 after end column ✅ Phase 2 - Prefix sum: Accumulate row-wise to get final values ✅ Optimization: Instead of updating entire submatrix, just mark endpoints! The key insight: This is the classic difference array pattern! Instead of incrementing every cell in a range, we mark the boundaries: - Add +1 at the start of the range - Add -1 just after the end of the range - Then do prefix sum to "materialize" the actual values Why it works: Without optimization: Update every cell in [c1, c2] for rows [r1, r2] → O(rows × cols) per query With difference array: Mark 2 positions per row → O(rows) per query Final prefix sum: O(n²) once at the end Example: Range [1,2] in row 0 - Before prefix: [0, +1, 0, -1, 0] - After prefix: [0, 1, 1, 0, 0] ✓ Time: O(q×n×n) → O(q×n + n²) | Space: O(n²) #LeetCode #DifferenceArray #CPlusPlus #Algorithms #SoftwareEngineering #ProblemSolving #RangeUpdate #Optimization

🚀 Day 125 of #LeetCode Challenge! Problem: Binary Tree Preorder Traversal 💡 My Approach: The goal is to perform a preorder traversal of a binary tree — visiting nodes in the order: Root → Left → Right Here’s the step-by-step logic: Start from the root node. Visit (record) the root value first. Recursively traverse the left subtree, then the right subtree. Store values in a vector as you go. ✨ Example Input: [1, null, 2, 3] Output: [1, 2, 3] 🧠 Key Idea Preorder traversal is useful when you need to copy or serialize a tree — it captures the structure starting from the root. ⏱ Complexity TypeValueTimeO(N) — each node visited onceSpaceO(H) — recursion stack (H = height of tree) 📎 GitHub Link: https://lnkd.in/gZ6GeXzm #LeetCode #BinaryTree #PreorderTraversal #Recursion #DSA #C++ #ProblemSolving #CodingChallenge #Day125

 Day 6 – LeetCode Challenge Today, I solved Problem #128: “Longest Consecutive Sequence” using C++. 🔍 Problem Overview: The task is to find the length of the longest consecutive elements sequence in an unsorted integer array. The key challenge is to ensure the solution works in O(n) time complexity. 💡 Approach: To achieve linear time, I used an unordered_set to quickly check if a number exists. For each number, I only begin counting a sequence when it is the start of a new streak (i.e., (num - 1) does not exist in the set). This ensures each number is processed only once. 🧠 Algorithm Design: Insert all elements into an unordered_set for O(1) average lookups. For every number, check if it's the start of a sequence. If yes, count forward (num + 1, num + 2, ... ) while elements exist in the set. Track and update the maximum streak length. ⏱ Time Complexity: O(n) 📌 Space Complexity: O(n) #LeetCode #CPlusPlus #DSA #100DaysOfCode #ProblemSolving #Algorithms #CodingChallenge #TechCommunity #GeetaUniversity

Today I solved the Reverse Integer problem on LeetCode — a classic challenge that tests how well you handle numeric operations and overflow conditions in a constrained environment. 🧩 Problem Summary: Given a signed 32-bit integer x, return the integer obtained by reversing its digits. If reversing x causes it to go outside the 32-bit signed integer range [-2³¹, 2³¹ - 1], return 0. ⚙️ Approach: Initialize revNum = 0 to store the reversed number. Extract the last digit of n using dig = n % 10. Before updating, check for overflow: If revNum > INT_MAX / 10 or revNum < INT_MIN / 10, return 0. Append the digit: revNum = revNum * 10 + dig. Remove the last digit from the original number: n = n / 10. Continue until all digits are processed. Return the final reversed integer. This ensures safety against integer overflow without using 64-bit integers — a key constraint of the problem. ⏱️ Time Complexity: O(log₁₀(n)) → Each iteration processes one digit. 💾 Space Complexity: O(1) → Constant extra space used. 🧠 Concepts Practiced: Integer manipulation Overflow handling Edge case analysis Bit-width constraints #LeetCode #Cplusplus #DSA #ProblemSolving #CodingJourney #CodeWithConsistency #Programming #Learning

Data Structures & Algorithms: Merging Two Sorted Linked Lists For my lab assignment, I tackled the LeetCode problem “Merge Two Sorted Lists” using C++ linked lists and pointer manipulation. 🔹 My Approach: I compared the first nodes of both lists, chose the smaller one as the head, and then iteratively attached the next smallest nodes using a pointer (curr). Once one list was exhausted, I simply linked the remaining nodes from the other list to finish the merge efficiently. 🔹 Key Concepts Covered: • Linked Lists • Pointer updates • Iterative merging ⏱ Time Complexity: O(n + m) This assignment really strengthened my understanding of linked list traversal and handling edge cases effectively. 🎥 Check out my video explanation: https://lnkd.in/dgZRyjj2 💡 Fun fact: I realized that merging linked lists is much easier in code than in real life—thankfully! #DSA #LabAssignment #LeetCode #C++ #CodingPractice #ProblemSolving #MergeTwoSortedLists

Today, I implemented a program to find all permutations of a string using recursion, inspired by Aditya Verma’s approach. At first, it looked like just another coding problem... but when I visualized it, something clicked. 💡 Real-life analogy: Imagine you’re trying to arrange 3 books — A, B, and C — on a shelf. You pick one book (say A) and keep it on the first spot. Now you’re left with 2 books (B and C). You repeat the same step — pick one, place it, and continue. You’re basically fixing one and arranging the rest, which is exactly what recursion does here! Each recursive call is like asking a smaller version of yourself to finish the remaining arrangements 😄 Here’s what I learned: ✅ Recursion isn’t about memorizing steps — it’s about trusting smaller problems to solve the big one. ✅ Each function call gets its own copy of the string (call by value), making the logic clean and independent. ✅ Smart work was visualizing recursion as a decision tree 🌳; Hard work was debugging every swap, substring, and counter to ensure accuracy. #100DaysOfCode #DSA #Recursion #Cplusplus #CodingJourney #AdityaVerma #SoftwareEngineering #SmartWork #HardWork #Learning