LeetCode 90 Subsets II with Duplicates

#200DaysOfCode – Day 108 Combination Sum III Problem:- Combination Sum III Task:- Find all valid combinations of k numbers that sum up to n, using only numbers from 1 to 9, where: Each number is used at most once No duplicate combinations are allowed Example: Input: k = 3, n = 7 Output: [[1, 2, 4]] My Approach:- Used Backtracking (DFS) to explore all possible combinations. Started from a given number to avoid duplicates. Stopped recursion when: The combination size exceeded k The sum became negative Added the combination to the result only when: Exactly k numbers were chosen The sum became 0 Time Complexity:- Exponential (bounded due to range 1–9) Space Complexity:- O(k) (recursive stack + temporary list) Backtracking may look complex at first, but with clear base conditions and pruning, it becomes a powerful and elegant tool for solving combination problems efficiently. #takeUforward #200DaysOfCode #Java #ProblemSolving #LeetCode #Backtracking #Recursion #DSA #CodingJourney #CodeNewbie

📅 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

🔹 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

#day280 of #1001daysofcode problem statement (0085): Maximal Rectangle. For each row, I converted the matrix into a histogram of consecutive 1s and didn't change the Largest Rectangle in Histogram code which i uploaded earlier. Key takeaway: -> Break problems into familiar subproblems   -> Reusability of concepts matters more than memorizing solutions   -> In histogram-based solutions, resetting height on '0' is crucial   #DSA #Java #LeetCode #ProblemSolving Shivam Mahajan #leetcode #1001daysofcode

#PostLog92 LeetCode 1704: Determine if String Halves Are Alike 🧵🔍 Another problem locked in, another concept strengthened ✅ This one leaned on clean string handling and a neat two-pointer approach to compare both halves efficiently ⚙️📊 Key takeaways from this problem: 🧩 Breaking problems into helper functions 🔍 Case normalization for simpler logic 🔄 Traversing from both ends with clarity Writing readable and maintainable code #LeetCode1704 #DetermineIfStringHalvesAreAlike #DSA #Java #ProblemSolving #LearningInPublic #CodingJourney

Day 7/100 – LeetCode Challenge 🚀 Problem: Remove Element Approach: Used two pointers Shifted non-matching elements to the front Returned the count of valid elements Time Complexity: O(n) Space Complexity: O(1) (in-place) Key takeaway: In-place array problems often reduce to index management, not extra data structures. #LeetCode #100DaysOfCode #DSA #Java #ProblemSolving #InterviewPrep #100DaysOfLeetCode

Day 13/100 – LeetCode Challenge 🚀 Problem: Binary Search Approach: Maintained left and right pointers Compared middle element with target Reduced the search space by half each step Time Complexity: O(log n) Space Complexity: O(1) Key takeaway: Binary search is the foundation for solving problems with logarithmic efficiency. #LeetCode #100DaysOfCode #DSA #Java #ProblemSolving #InterviewPrep #100DaysOfLeetCode

Day: 23/365 Problem: Minimum Cost to Convert String I Medium Key takeaways/Learnings from this problem: 1. Floyd–Warshall is clutch when you need all-pairs minimum cost, especially with character-to-character conversions. 2. Precomputing the cheapest path once saves you from doing repeated work for every character in the string. 3.This problem is a good reminder that classic graph algos + small constraints = clean and elegant solution. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #Consistency 🥷

Solved LeetCode 4 – Median of Two Sorted Arrays ✅ Yeah, I know. This is a Hard problem and the expected solution is O(log(min(n, m))) using binary search and partitioning. But today, I went with clarity first. I combined both arrays, sorted them, and directly computed the median. 📌 Result? ✔️ All test cases passed ✔️ Correct output ✔️ Clear logic Is it the optimal solution? ❌ Is it a valid one? ✅ And that’s the point. Sometimes the real learning is: Understanding why a brute-force solution works Then understanding why it’s not optimal And only then moving to the complex solution Hard problems aren’t solved in one jump. They’re solved in iterations. Binary search partitioning is next. But today, correctness comes first. #LeetCode #DSA #ProblemSolving #Java #CodingJourney #LearningInPublic #Consistency