Combination Sum II LeetCode Solution

🚀 Day 4 of #100DaysOfCode Solved Single Element in a Sorted Array on LeetCode using Binary Search ⚡ 🧠 Key insight: In a sorted array where every element appears twice except one, index parity (even/odd) helps decide which half to search. ⚙️ Approach: 🔹Apply binary search 🔹Compare mid with its adjacent element 🔹Use index parity to move left or right 🔹Narrow down until the single element is found ⏱️ Time Complexity: O(log n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #BinarySearch #Java #ProblemSolving #LearningInPublic #CodingJourney

🚀 Day 13 of #100DaysOfCode Solved Remove Linked List Elements on LeetCode 🔗 🧠 Key insight: While traversing a linked list, careful pointer updates are needed—especially when the head node itself matches the value to be removed. ⚙️ Approach: 🔹Handle cases where the head contains the target value 🔹Traverse the list using a pointer 🔹Skip nodes whose value matches the given target by adjusting next pointers ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney

🔹 Day 85 – #100DaysOfLeetCode Problem: 3010. Divide an Array Into Subarrays With Minimum Cost I Difficulty: Easy Key Insight: The cost of a subarray depends only on its first element. Since the first subarray always starts at index 0, the problem reduces to selecting the two smallest possible starting elements from the remaining array. Approach: Fix the first subarray cost as nums[0] Find the smallest and second smallest values in nums[1…n-1] Add them to get the minimum total cost Time Complexity: O(n) Space Complexity: O(1) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

🔥 Day 82 of #100DaysOfLeetCode ✅ Problem: Number of Longest Increasing Subsequence ✅ Difficulty: Medium 💡 Key Insight: Instead of tracking only the LIS length, we also maintain the number of ways each LIS can be formed. For every element, we check all previous smaller elements and update both length and count dynamically. 🛠 Approach: Use two arrays: dp[i] → Length of LIS ending at index i cnt[i] → Number of LIS ending at index i If a longer subsequence is found → update length and copy count. If another subsequence of the same length is found → add the counts. Finally, sum counts for indices having the maximum LIS length. ⏱ Complexity: Time: O(n²) Space: O(n) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

Day 3 of Daily DSA 🚀 Solved LeetCode 1: Two Sum Approach: Used a HashMap to store numbers with their indices. For each element, checked if the complement (target - current) already exists. Complexity: • Time: O(n) • Space: O(n) Performance: Runtime: 2 ms (Beats 99.15%) Memory: 47.34 MB Focusing on writing clean and efficient solutions before over-optimizing. Consistency > Intensity 💯 #DSA #LeetCode #Java #ProblemSolving #Consistency

🚀 Day 95 of #100DaysOfLeetCode 📌 Problem 216. Combination Sum III 🟡 Difficulty Medium 🛠️ Approach Use a recursive backtracking function. Maintain: k → numbers left to pick n → remaining sum start → next number to try (to avoid duplicates) ans → current combination If k == 0 and n == 0, add the combination to result. Iterate from start to 9, pick number, recurse, then backtrack. #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

Day 27/100 – LeetCode Challenge 🚀 Problem: Sort List Approach: Applied Merge Sort on the linked list Used slow and fast pointers to find the middle Recursively sorted both halves Merged the sorted halves Time Complexity: O(n log n) Space Complexity: O(log n) (recursion stack) Key takeaway: Merge sort is the most efficient sorting technique for linked lists, as it avoids random-access operations required by other algorithms. #LeetCode #100DaysOfCode #DSA #Java #LinkedList #MergeSort #ProblemSolving

🚀 Day 14 of #100DaysOfCode Solved Merge Two Sorted Lists on LeetCode 🔗🔀 🧠 Key insight: Using a dummy (sentinel) node simplifies pointer handling and avoids edge cases when building the merged list. ⚙️ Approach: 🔹Initialize a dummy node to act as the start of the merged list 🔹Compare nodes from both lists one by one 🔹Attach the smaller node and move the pointer forward 🔹Append remaining nodes once one list is exhausted ⏱️ Time Complexity: O(n + m) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney

 Day 11 of my #LeetCodeDailyChallenge Today’s problem: Valid Parentheses Topic: Stack | Strings Difficulty: Easy In this problem, I practiced using a stack data structure to validate whether brackets in a string are properly opened and closed. It strengthened my understanding of how Last-In-First-Out logic helps track matching pairs efficiently and detect invalid sequences early. Key learnings: Practical use of stack for pattern validation Importance of mapping pairs correctly Writing clean conditional logic for edge cases Daily consistency is helping me improve both problem-solving speed and coding clarity. #DSA #Java #CodingJourney #ProblemSolving #LearningInPublic

📌 Day 93 of #100DaysOfLeetCode Problem: 1382. Balance a Binary Search Tree Difficulty: Medium Key Insight: An inorder traversal of a BST produces a sorted sequence. A height-balanced BST can be built by recursively choosing the middle element of this sorted list as the root. Approach: Perform inorder traversal to store node values in a list Recursively construct a balanced BST using the middle element as root Left subtree from left half, right subtree from right half Time Complexity: O(n) Space Complexity: O(n) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday