Combination Sum with Backtracking Algorithm

🔥 DSA Challenge – Day 127/360 🚀 📌 Topic: Backtracking 🧩 Problem: Subsets II Problem Statement: Given an integer array that may contain duplicates, return all possible subsets such that the solution set does not contain duplicate subsets. 🔍 Example: Input: nums = [1,2,2] Output: [[], [1], [1,2], [1,2,2], [2], [2,2]] 💡 Approach: Backtracking + Sorting 1️⃣ Step 1 – Sort the array to group duplicate elements together 2️⃣ Step 2 – Use recursion to generate all subsets 3️⃣ Step 3 – Skip duplicate elements using condition (i != ind && nums[i] == nums[i-1]) ⏱ Complexity: Time: O(2^n) Space: O(n) (recursion stack + subset storage) 📚 Key Learning: Sorting + smart skipping of duplicates helps avoid repeated subsets in backtracking problems. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode #Backtracking

🔥 DSA Challenge – Day 126/360 🚀 📌 Topic: Array + Backtracking (Recursion) 🧩 Problem: Combination Sum II Problem Statement: Find all unique combinations in an array where numbers sum up to a target. Each number can be used only once, and duplicate combinations are not allowed. 🔍 Example: Input: candidates = [10,1,2,7,6,1,5], target = 8 Output: [[1,1,6], [1,2,5], [1,7], [2,6]] 💡 Approach: Backtracking + Pruning 1️⃣ Step 1 – Sort the array to handle duplicates easily 2️⃣ Step 2 – Use recursion to pick elements and reduce target 3️⃣ Step 3 – Skip duplicates & backtrack after each recursive call 👉 Use condition to skip duplicates: if(i > ind && arr[i] == arr[i-1]) continue; 👉 Stop early if element exceeds target (pruning) ⏱ Complexity: Time: O(2^n) Space: O(k * x) (for storing combinations) 📚 Key Learning: Sorting + duplicate skipping is the key trick to avoid repeated combinations in backtracking problems. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode

🔥 DSA Challenge – Day 123/360 🚀 📌 Topic: Recursion 🧩 Problem: Generate Parentheses Problem Statement: Given n pairs of parentheses, generate all combinations of well-formed (valid) parentheses. 🔍 Example: Input: n = 3 Output: ["((()))","(()())","(())()","()(())","()()()"] 💡 Approach: Backtracking 1️⃣ Step 1 – Start with an empty string and track open (oc) and close (cc) brackets 2️⃣ Step 2 – Add "(" if oc < n (we still have opening brackets left) 3️⃣ Step 3 – Add ")" only if cc < oc (to maintain valid structure) 👉 This ensures we only generate valid combinations (no extra filtering needed) ⏱ Complexity: Time: O(2ⁿ) (Catalan growth) Space: O(n) recursion stack 📚 Key Learning: Backtracking works best when we avoid invalid choices early, instead of fixing them later. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #123DaysOfCode #LeetCode #Backtracking

🚀 Starting a New Topic: Recursion 🔥 DSA Challenge – Day 118/360 📌 Topic: String 🧩 Problem: String to Integer (atoi) Problem Statement: Convert a string into a 32-bit signed integer while handling spaces, sign, non-digit characters, and overflow. 🔍 Example: Input: " -42" Output: -42 💡 Approach: Recursion + Parsing 1️⃣ Step 1 – Skip leading spaces and detect sign (+ / -) 2️⃣ Step 2 – Recursively process each digit and build the number 3️⃣ Step 3 – Check overflow at every step and return result ⏱ Complexity: Time: O(n) Space: O(n) (recursive stack) 📚 Key Learning: Always handle overflow during computation, not after building the full number. Recursion simplifies problems by breaking them into smaller subproblems. 💭 New Topic Journey Begins: Excited to dive deep into Recursion and master it step by step! 💪 #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #118DaysOfCode #LeetCode #Recursion

🚀 Day 82 – DSA Journey | Same Tree using Recursion Continuing my daily DSA practice, today I worked on a problem that strengthened my understanding of tree comparison and recursion. 📌 Problem Practiced: Same Tree (LeetCode 100) 🔍 Problem Idea: Given two binary trees, determine whether they are identical in both structure and node values. 💡 Key Insight: To check if two trees are the same, we need to compare nodes at every level — both their values and their left & right subtrees. Recursion makes this process clean and intuitive. 📌 Approach Used: • If both nodes are null → trees match at this point • If one is null or values differ → trees are not the same • Recursively compare left subtrees • Recursively compare right subtrees • Both sides must match for the trees to be identical 📌 Concepts Strengthened: • Tree traversal • Recursion • Structural comparison • Base case handling ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) 🔥 Today’s takeaway: Tree problems often become simple when broken down recursively — solve smaller subtrees to solve the whole tree. On to Day 83! 🚀 #Day82 #DSAJourney #LeetCode #BinaryTree #Recursion #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 Day 15 of My DSA Journey Today’s problem: Array Rank Transform 💡 Problem Insight: Given an array, replace each element with its rank when the array is sorted. Rank starts from 1 Equal elements → same rank Ranks must be continuous (no gaps) 🧠 Approach: 🔹 Clone and sort the array 🔹 Use a HashMap to assign ranks to unique elements 🔹 Traverse original array and replace values using the map ⚡ Key Learning: 👉 This is a classic example of Coordinate Compression 👉 Helps reduce large values into a smaller ranked range 💻 Code Logic: Sort copy of array Assign rank only if element not already mapped Replace original values using the map 📊 Result: ✅ 43 / 43 test cases passed ⏱ Runtime: 31 ms 📈 Beat: 58.58% 💾 Memory: 74.74 MB (85.14% better than others) 💭 Takeaway: Simple problems can test clean thinking + handling duplicates properly. Hashing + sorting is a powerful combo 🔥 🔥 Consistency Check: Day 15 Complete Building discipline one problem at a time. #DSA #CodingJourney #LeetCode #Java #ProblemSolving #Consistency #100DaysOfCode

Day 1 of becoming DSA consistent (no excuses) Problem name : Minimum Distance Between Three Equal Elements II Difficulty : Medium Topic : Hash Table Most people would brute-force this problem… but there’s a smarter way using grouping. 🧠 Approach : 👉 Instead of comparing all triplets (which is slow), we optimize using a HashMap. Step 1: Store indices Traverse the array For each number, store all its indices in a map number → list of positions Step 2: Filter useful candidates Only consider numbers that appear at least 3 times Others cannot form a valid triplet Step 3: Check consecutive triplets For each list of indices: Pick 3 consecutive indices → (i, i+1, i+2) Since indices are sorted, this ensures minimum distance. Step 4: Compute distance, Distance is calculated between the 3 positions. Simplifies to: 2 × (last index − first index); Step 5: Track minimum. Keep updating the smallest distance found. If no valid triplet → return -1; Key Learning : When dealing with repeated elements: Use HashMap for grouping, Work on indices instead of values, Look for patterns (like consecutive grouping) to reduce complexity. IF YOU GUYS USED DIFFERENT LOGIC , Drop your logic below 👇... #leetcode #dsa #coding #softwareengineering #programming #interviewprep #java #grow #innovation #LetsConnect

🚀 Day 90 – DSA Journey | Binary Tree Paths Continuing my daily DSA practice, today I explored how to track and construct paths in a binary tree. 📌 Problem Practiced: Binary Tree Paths (LeetCode 257) 🔍 Problem Idea: Return all root-to-leaf paths in a binary tree as strings. 💡 Key Insight: While traversing the tree, we can build the path step by step. Once we reach a leaf node, we add the complete path to the result. 📌 Approach Used: • Use DFS traversal • Maintain a string to track the current path • At each node, append its value to the path • If it’s a leaf node → add the path to result • Continue exploring left and right subtrees 📌 Concepts Strengthened: • Tree traversal (DFS) • Recursion • Path tracking • String manipulation ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) 🔥 Today’s takeaway: Tracking state (like a path) during recursion is a powerful technique for solving tree problems. On to Day 91! 🚀 #Day90 #DSAJourney #LeetCode #BinaryTree #DFS #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 Day 19/100 — #100DaysOfLeetCode Back to mastering one of the most powerful patterns in DSA — Sliding Window 💻🔥 ✅ Problem Solved: 🔹 LeetCode 1358 — Number of Substrings Containing All Three Characters 💡 Concept Used: Sliding Window + Frequency Tracking 🧠 Key Learning: The goal was to count all substrings containing 'a', 'b', and 'c'. Instead of checking every possible substring, I learned how: Expand the window until all required characters are present. Once valid, every further extension also forms valid substrings. Count substrings efficiently while shrinking the window. This converts a brute-force O(n²) approach into an optimized O(n) solution. ⚡ Big Insight: Sliding Window isn’t just about finding length — it can also be used for counting valid substrings efficiently. Consistency is slowly turning patterns into instincts 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency

🔥 DSA Challenge – Day 131/360 🚀 📌 Topic: Backtracking / Recursion 🧩 Problem: N-Queens Problem Statement: Place N queens on an N×N chessboard such that no two queens attack each other. 🔍 Example: Input: n = 4 Output: [[".Q..","...Q","Q...","..Q."], ["..Q.","Q...","...Q",".Q.."]] 💡 Approach: Optimized Backtracking (Hashing) 1️⃣ Step 1 – Try placing a queen column by column 2️⃣ Step 2 – Use arrays to check if row & diagonals are safe in O(1) 3️⃣ Step 3 – Place queen → recurse → backtrack if needed ⏱ Complexity: Time: O(N!) Space: O(N) + recursion stack 📚 Key Learning: Using hashing for rows & diagonals avoids repeated checks and makes backtracking much faster ⚡ #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #131DaysOfCode #LeetCode