Combination Sum III: Backtracking Solution

🔹 Day 98 – LeetCode Practice 📌 Problem: Path Sum II (LeetCode #113) 📊 Difficulty: Medium 🧠 Problem Overview: Given the root of a binary tree and a target sum, the task is to find all root-to-leaf paths where the sum of node values equals the target. Each valid path should be returned as a list of values. ✅ Approach Used: Traversed the tree using depth-first search. Maintained the current path and cumulative sum while moving down the tree. When a leaf node was reached, checked if the sum matched the target. Used backtracking to explore all possible paths correctly. 📈 Submission Results: Status: Accepted ✅ Runtime: 2 ms Memory Usage: 45.54 MB 💡 Reflection: This problem is a great example of how recursion and backtracking work together in tree problems. Managing state carefully is key to collecting all valid paths without duplication. #LeetCode #BinaryTree #DFS #Backtracking #Java #DSA #CodingPractice

🚀 DSA Day 3 | Arrays & Prefix Sum (Java) Today’s focus was on Prefix Sum, an important array technique that helps optimize range sum queries efficiently. ✅ What I learned: How to build a prefix sum array Difference between in-place and extra array prefix sums How prefix sum reduces time complexity from O(n) to O(1) for range queries Solved multiple practice problems to strengthen logic 🧠 Key Insight: Pre-computation makes problem solving faster and cleaner. Consistency over motivation. One day at a time 💪 #DSA #Java #PrefixSum #Arrays #CodingJourney #LearningEveryDay #100DaysOfCode

🔹 Day 97 – LeetCode Practice 📌 Problem: Divide Array Into Equal Pairs (LeetCode #2206) 📊 Difficulty: Easy 🧠 Problem Overview: You’re given an integer array containing 2n elements. The goal is to check whether the array can be divided into n pairs such that: Every element is used exactly once Both elements in each pair are equal ✅ Approach Used: Sorted the array to bring identical elements together. Traversed the array while counting occurrences of each number. Verified that every number appears an even number of times, ensuring valid pairs. 📈 Submission Results: Status: Accepted ✅ Runtime: 8 ms Memory Usage: 46.94 MB 💡 Reflection: This problem is a great reminder that sorting can simplify pairing logic significantly. Once the array is ordered, validating pairs becomes straightforward and efficient. #LeetCode #ProblemSolving #Arrays #Java #DSA #CodingPractice #Consistency

📅 Day 80 of #100DaysOfLeetCode 🧩 Problem: 3819. Rotate Non-Negative Elements Difficulty: Medium 💡 Key Insight Negative elements must act like fixed blockers. So instead of rotating the entire array, we: Extract only non-negative elements Rotate that extracted list Put them back only into non-negative positions This avoids disturbing any negative indices 🚫. 🛠️ Approach Count how many non-negative elements exist (pc). Reduce k using k % pc to avoid unnecessary rotations. Store all non-negative elements in a temporary array. Perform left rotation using the reverse array technique: Reverse first k elements Reverse remaining elements Reverse the whole array Traverse the original array and replace only non-negative positions with rotated values. ⏱️ Complexity Time: O(n) Space: O(pc) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

#200DaysOfCode – Day 110 Palindrome Partitioning Task: Given a string s, partition it such that every substring is a palindrome, and return all possible valid partitions. Example: Input: s = "aab" Output: [["a","a","b"], ["aa","b"]] My Approach: Used Backtracking to explore all possible partitions. At each step, checked whether the current substring is a palindrome. If valid, added it to the path and continued recursively. Backtracked to explore other possibilities. Time Complexity: Exponential (due to all possible partitions) Space Complexity: O(N) (recursion stack) Backtracking problems may look complex at first, but breaking them into choices, constraints, and recursion makes them much more manageable. #takeUforward #200DaysOfCode #Java #ProblemSolving #LeetCode #Backtracking #Recursion #DSA #CodingJourney #CodeNewbie

Day 29/100 ✅ LeetCode 138: Copy List with Random Pointer Solved this problem by creating a deep copy of a linked list where each node contains an additional random pointer. The approach ensures that both next and random pointers are copied correctly without modifying the original list. Key steps involved: Create copied nodes Link copied nodes with original nodes Assign random pointers efficiently Separate the original and cloned lists This problem helped me strengthen my understanding of linked list manipulation and pointer mapping. Solution:-https://lnkd.in/gD9TWWsg #LeetCode #LeetCode138 #CopyListWithRandomPointer #LinkedList #DSA #Java #ProblemSolving #CodingPractice #DeepCopy #DataStructures #Day29

🌟 Day 25/30 – Remove Nth Node From End of Linked List Approach: Use a dummy node to simplify edge cases (like removing the head). Move the head pointer n steps ahead. Move both pointers together until head reaches null. Delete the target node by skipping it (dummy.next = dummy.next.next). Complexity: Time: O(n) Space: O(1) Key Takeaway: Two-pointer technique with a dummy node makes linked list deletions clean and avoids special-case handling. #25Day #DSA #LinkedList #TwoPointers #LeetCode #Java #ProblemSolving #CodingJourney #30DayChallenge

Day 24 / #100DaysOfCode LeetCode 1877 — Minimize Maximum Pair Sum in Array (Medium) Problem (short): Given an array of even length, pair up all elements such that the maximum pair sum is minimized. Each element must be used exactly once. Key Insight: - To minimize the maximum pair sum, we must balance extremes. - Pairing large numbers together increases the maximum. - Pairing small numbers together wastes the chance to offset large values. So the optimal strategy is: - Sort the array - Pair the smallest with the largest, second smallest with second largest, and so on - Track the maximum among these pair sums This greedy pairing ensures no pair becomes unnecessarily large. Approach: 1. Sort the array 2. Use two pointers from both ends 3. For each pair, compute sum and update the maximum - Time Complexity: O(n log n) - Space Complexity: O(1) (ignoring sort space) #Leetcode #DSA #Java