Solved Subsets (Power Set) with Backtracking and Recursion

🔹 Day 65 of #100DaysOfLeetCodeChallenge 🔹 Problem: Generate Parentheses Focus: Recursion + Backtracking 💡 The Challenge: Generate all valid combinations of n pairs of parentheses. Sounds simple? The trick is ensuring every string remains valid throughout construction! 🧠 My Approach: Used backtracking to build strings intelligently: Add '(' when we haven't used all n opening brackets Add ')' only when it won't break validity (close < open) Base case: Both counts reach n → valid combination found! ✅ 📊 Complexity Analysis: ⏳ Time: O(2ⁿ) — exploring possible combinations 💾 Space: O(n) — recursion stack depth 📌 Example: Input: n = 3 Output: ["((()))","(()())","(())()","()(())","()()()"] 🎯 Key Takeaway: Backtracking shines when you need to explore all possibilities while intelligently pruning invalid paths. This problem perfectly illustrates the power of constraint-based recursion! What's your favorite backtracking problem? Drop it in the comments! 👇 Day 65/100 complete. Onwards to mastering DSA, one problem at a time! 💪 #LeetCode #Algorithms #DataStructures #BacktrackingAlgorithms #TechCareers #SoftwareEngineering #CodingJourney #LearnInPublic

𝗘𝘅𝗽𝗹𝗼𝗿𝗶𝗻𝗴 𝘁𝗵𝗲 𝗧𝘄𝗼 𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝘀 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 Today, I explored one of the most efficient problem-solving patterns — the 𝗧𝘄𝗼 𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝘀 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 🔥 It’s a simple yet powerful concept where we use 𝘁𝘄𝗼 𝘃𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 (𝗽𝗼𝗶𝗻𝘁𝗲𝗿𝘀) to traverse data structures like arrays or strings — either 𝗳𝗿𝗼𝗺 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗱𝗶𝗿𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝗼𝗿 𝗮𝘁 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝘀𝗽𝗲𝗲𝗱𝘀. This technique helps reduce complex problems from O(n²) to O(n), making our solutions both faster and cleaner ⚡ I’ve documented everything with explanations and step-by-step logic here 👇 🔗 𝗚𝗶𝘁𝗛𝘂𝗯: https://lnkd.in/grDc3Zwu Let’s continue learning patterns and solving problems efficiently! 💪 #LeetCode #TwoPointers #ProblemSolving #CodingPatterns #Algorithms #DataStructures #LearningEveryday #GitHubProjects

🔹 Day 67 of #100DaysOfLeetCodeChallenge 🔹 Problem: Combination Sum Focus: Backtracking + Recursion 💡 The Challenge: Find all unique combinations of numbers that sum to a target. The twist? You can reuse the same number unlimited times! This makes it more interesting than standard subset problems. 🧠 My Approach: Used backtracking with two key decisions at each step: Pick: Include current element and explore further (stay at same index for reuse) Skip: Move to next element without including current one Base case: When we've explored all elements, check if target reached 0 Optimization: Only pick if element ≤ remaining target 📊 Complexity Analysis: ⏳ Time: O(2^t) where t = target/min(candidates) — worst case recursion tree 💾 Space: O(t) — maximum recursion depth 📌 Example: Input: candidates = [2,3,6,7], target = 7 Output: [[2,2,3],[7]] Explanation: - 2+2+3 = 7 (reused 2 twice!) - 7 = 7 (single element) 🎯 Key Takeaway: The beauty of this problem lies in handling unlimited reuse. By staying at the same index when picking an element, we elegantly allow repetition without creating duplicates. This pick/skip pattern is fundamental to combinatorial backtracking! Real-world analogy: Like making change for a dollar — you can use the same coin denomination multiple times! 💰 Day 67/100 complete. Mastering backtracking, one problem at a time! 💪 #LeetCode #Backtracking #DynamicProgramming #DSA #Algorithms #CodingInterview #100DaysOfCode #SoftwareEngineering #ProblemSolving #TechCareer

🚀 Day 68 of #100DaysOfLeetcodeHard — LeetCode 2382: Maximum Segment Sum After Removals (Hard) My Submission:https://lnkd.in/g-X4k2Hd Today’s challenge was a Disjoint Set Union (Union-Find) problem with a clever reverse processing approach. 🧩 Problem Summary: We start with an array and remove elements one by one, needing to track the maximum segment sum of contiguous non-removed elements after each removal. Instead of simulating removals forward (which is difficult to track), we reverse the process — ✅ Start from an empty array and add elements back in reverse order. ✅ Use Union-Find (Disjoint Set) to merge adjacent active segments and maintain their sums dynamically. 💡 Approach: Each index starts as its own segment with rank[i] = nums[i] (used to store segment sums). When a new index is added, we union it with its active neighbors (if any). Track the maximum segment sum after each merge. 🧠 Key Concepts Used: Union-Find with path compression & rank to efficiently merge contiguous segments. Reverse iteration to avoid handling splits directly. 📈 Complexity: Time: O(n α(n)) ≈ O(n) (inverse Ackermann function for DSU) Space: O(n) A beautiful mix of data structures + reverse simulation + problem insight — one of those problems that truly sharpen algorithmic thinking. ⚡ #LeetCode #UnionFind #DSU #ProblemSolving #AlgorithmDesign #DataStructures #CodingChallenge #100DaysOfCode #LearningEveryday

📌 Day 39/150 – Rotate List (LeetCode #61) Today’s problem was a brilliant exploration of how subtle linked list operations can completely change the shape of a data structure! 🔁✨ The task? Given a linked list, rotate it to the right by k positions. Instead of shifting values, we must carefully adjust the links — no cheating with arrays! 😄 This problem reinforces how pointer manipulation and structural thinking work hand-in-hand in linked list questions. 🧠 🔹 Brute Force Idea A naive thought would be: 👉 Rotate one step at a time 👉 Move the last node to the front Repeat this k times. ✅ Easy to visualize ❌ Too slow (k rotations × n operations = inefficient!) ❌ Not scalable for large k 🔹 Optimal Approach – Smart Pointer Manipulation The elegant approach lies in understanding patterns: 👉 First, compute the length of the list. 👉 Connect the tail to the head — forming a temporary circle! 🔄 👉 Reduce k using modulo (k = k % length) 👉 Traverse to the correct breaking point. 👉 Break the circle to form the rotated list. You handle: 🔸 Circular linked list logic 🔸 Tail–head reattachment 🔸 Precise pointer breaking Very clean, very efficient! ✨ 🧠 Example Visualization Input: 1 → 2 → 3 → 4 → 5, k = 2 After rotation: 4 → 5 → 1 → 2 → 3 Only the links change — the magic of pointers! 🔧 ⏱️ Time & Space Complexity ComplexityValueTimeO(n) — just one traversalSpaceO(1) — done in-place 💡 Key Learning: This problem helps build confidence in: ✅ Recognizing patterns ✅ Using circular logic ✅ Efficient pointer manipulation ✅ Avoiding unnecessary extra space It’s one of those linked list questions that feels intimidating at first, but becomes satisfying once you see the strategy. Solving this opens the door to related problems like: 📍 Rotate Array 📍 Reverse Nodes in K-Group 📍 Swap Nodes in Pairs Linked lists may bend… but they don't break your confidence anymore. 💪😄 #150DaysOfCode #LeetCode #RotateList #LinkedLists #Pointers #DSA #CodingChallenge #SoftwareEngineering #LearningJourney #ProblemSolving 🚀🔥

🚀 Two Pointer Technique — The Hidden Gem of Optimized Problem Solving The Two Pointer technique is one of those elegant patterns that transforms nested loops into clean O(n) solutions. It’s all about using two indices that move through your data — sometimes from opposite ends, sometimes together — to efficiently compare, partition, or traverse arrays and strings. Whether it’s finding pairs with a target sum, removing duplicates in-place, or checking for palindromes, the principle stays the same: 👉 Use movement, not brute force. Instead of restarting the search every time, the Two Pointer method lets you reuse previously processed data, dramatically reducing unnecessary computations. From array problems to linked lists, and even complex challenges like “Container With Most Water” or “3Sum,” mastering this pattern unlocks a new level of clarity and performance in your problem-solving approach. Follow Codekerdos for more algorithm deep-dives, clean code patterns, and practical insights that sharpen your developer mindset 🔥 #Algorithms #TwoPointer #ProgrammingTips #DeveloperMindset #Codekerdos #CleanCode #SoftwareEngineering #100DaysOfCode #google

#DSAChallenge | #LeetCodeProgress 📌 Problem: 54.Spiral Matrix 📍 Platform: LeetCode Over the past few days, I’ve been exploring some classic yet challenging LeetCode problems — the kind that really test your understanding of logic, edge cases, and clean code design. 🧠 Problem Insight You're given a matrix, and the goal is to return all elements in spiral order — starting from the top-left corner and moving right → down → left → up, repeating this pattern until all elements are covered. ⚙️ Logic Breakdown (Step-by-Step): 1️⃣ Set boundaries: top, bottom, left, right 2️⃣ Traverse in order: → Move left to right (top row) → top++ → Move top to bottom (right column) → right-- → Move right to left (bottom row) → bottom-- → Move bottom to top (left column) → left++ 3️⃣ Continue while top <= bottom and left <= right 🧩 Key Learning Points: ✅ Strengthened my understanding of matrix boundaries and directions. ✅ Improved my ability to handle edge cases cleanly. ✅ Learned how to manage loop conditions efficiently. ⏱️ Time & Space Complexity Time Complexity: O(m × n) → Every element is visited once Space Complexity: O(1) → If output list is excluded 💡 Takeaway: In DSA, consistency beats intensity. Even small daily challenges — when done consistently — compound into stronger problem-solving intuition. 🔥 Next Up: Moving on to Rotate Image & Set Matrix Zeroes to deepen my matrix manipulation skills! #DSA #LeetCode #ProblemSolving #DataStructures #Algorithms #100DaysOfDSA #Matrix #SpiralMatrix #CodeNewbie #GrowthMindset #DailyLearning #NeverGiveUp #KeepCoding #LearningNeverStops

🔹 Problem: Binary Tree Inorder Traversal Day 122 🔹 Difficulty: Easy 🔹 Topic: Binary Tree / Morris Traversal / Iterative Traversal 🔍 Problem Breakdown: We are given the root of a binary tree, and we need to return the inorder traversal of its nodes’ values. 📘 Inorder Traversal: Left → Root → Right Usually, this can be solved using recursion or stack, but today’s approach uses Morris Traversal, which is O(1) extra space and does not use recursion or stack. 🧠 Approach (Morris Traversal): Start with the current node = root. If the left child is NULL, visit the node and move right. Else, find the inorder predecessor (rightmost node in the left subtree). If predecessor’s right is NULL, make a temporary link to the current node and move left. If predecessor’s right is current, remove the link, visit current node, and move right. Continue until all nodes are visited. This method avoids recursion and stack by establishing temporary links in the tree. ⏱️ Time & Space Complexity: Time Complexity: O(n) — each edge is visited twice. Space Complexity: O(1) — no recursion or stack used. 💡 Key Insight: Morris Traversal is a brilliant way to traverse binary trees in constant space, by cleverly using tree links as temporary pointers — elegant and efficient! #LeetCode #DSA #BinaryTree #MorrisTraversal #InorderTraversal #ProblemSolving #CodingChallenge #200DaysOfCode #Cplusplus

🚀Day 77 of #120_Days_leetCode Challenge ! LeetCode Problem: Find and Replace Pattern Today’s problem was all about pattern matching with bijective mappings — where we find words that match a given pattern by establishing a one-to-one relationship between letters. 🧩 Problem Summary: Given a list of words and a string pattern, return all words that match the pattern. A word matches if you can permute letters such that each letter in the pattern maps uniquely to a letter in the word. 📘 Example: Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb" Output: ["mee","aqq"] 💡 Intuition: To verify a match, we need to ensure: Each character in the pattern maps to only one unique letter in the word. No two pattern characters map to the same word character. This makes it a bijection problem — a perfect use case for hash maps. 🧠 Key Takeaways: Used two hash maps to maintain bijective character mapping. Achieved O(n * k) time complexity, where n = number of words and k = word length. Great practice for mastering string and hashmap-based logic problems. ✨ Every such problem reinforces how powerful simple mapping logic can be when applied thoughtfully. #LeetCode #ProblemSolving #CodingChallenge #DataStructures #Algorithms #ProgrammingJourney

#Day17 of #100DaysOfCoding Challenge 🧮 Problem: Perfect Sum Problem (Count subsets with given sum) 🧠 Problem Statement: Given an array arr[] of non-negative integers and an integer target, count all subsets of the array whose sum equals the target. 🧮 Examples: Input: arr = [5, 2, 3, 10, 6, 8], target = 10 Output: 3 Explanation: Subsets {5,2,3}, {2,8}, and {10} sum to 10. Input: arr = [2, 5, 1, 4, 3], target = 10 Output: 3 Explanation: {2,1,4,3}, {5,1,4}, {2,5,3}. Input: arr = [5,7,8], target = 3 Output: 0 Input: arr = [35,2,8,22], target = 0 Output: 1 Explanation: Only the empty subset sums to 0. ⚙️ Constraints: 1 ≤ n = arr.size() ≤ 10^3 0 ≤ arr[i] ≤ 10^3 0 ≤ target ≤ 10^3 💡 Approach (Dynamic Programming — Count of subset sums) Use a DP array dp[0..target] where dp[s] = number of subsets using processed items that sum to s. Initialization: dp[0] = 1 (empty subset gives sum 0) Transition for each number num: iterate s from target down to num: dp[s] += dp[s - num] Use reverse iteration to avoid reusing the same element multiple times in one iteration (0/1 subset). This gives O(n * target) time and O(target) space.