Generating Parentheses Combinations with Backtracking

DSA Practice – Day 68 🚀 Problem: Subsets II (LeetCode 90) ✨ Brute Force Approach 1. Generate all possible subsets using recursion (like Subsets I). 2. Use a Set or HashSet to store unique subsets and avoid duplicates. 3. Convert the set back to a list before returning the result. Time Complexity: O(2ⁿ × n) (to generate all subsets) Space Complexity: O(2ⁿ × n) (storing all subsets) ✨ Optimal Approach (Backtracking with Duplicate Handling) We use backtracking, but with a twist — handle duplicates smartly. Steps: 1. Sort the array so duplicates come together. 2. Use a loop with a check if(i != ind && nums[i] == nums[i - 1]) continue; to skip duplicates. 3. Recursively generate subsets and backtrack after each recursive call. Time Complexity: O(2ⁿ × n) Space Complexity: O(n) 🌟 Key Idea Sorting + Skipping duplicates ensures we only generate unique subsets efficiently. #Day68 #Backtracking #DSA #Java #LeetCode #Placements

🚀 Just Solved LeetCode #1367 — Linked List in Binary Tree 📘 Problem: Given the head of a linked list and the root of a binary tree, determine whether all the elements of the linked list appear as a downward path in the binary tree. Downward means starting from any node and moving only to child nodes. Example: Input → head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3] Output → true Explanation → Nodes in blue form a subpath in the binary tree. 🧠 My Approach: I used recursion to check whether the linked list sequence can be found starting from any node in the binary tree. 1️⃣ For each node in the tree, check if the list starting from `head` matches the downward path from that node. 2️⃣ If not, recursively check the left and right subtrees. 3️⃣ Used a helper function `checkPath()` to verify if a valid path continues as the recursion goes deeper. 💡 What I Learned: ✅ How to combine linked list and binary tree traversal logic ✅ How recursion can efficiently check multiple starting points ✅ Improved my understanding of tree path traversal and backtracking logic #LeetCode #Java #DSA #BinaryTree #LinkedList #CodingUpdate #LearningByDoing

📌 Day 2/100 – Remove Element (LeetCode 27)  🔹 Problem:  Given an integer array nums and a value val, remove all instances of that value in-place and return the new length of the array. The order of elements can be changed. 🔹 Approach: Used the two-pointer technique to efficiently modify the array in-place. One pointer iterates through the array, while the other tracks the position to overwrite non-val elements. Returned the position of the second pointer as the new length. 🔹 Key Learning: Strengthened understanding of in-place array manipulation. Improved logic building for pointer movement and conditional overwriting. Learned how to minimize extra space usage while maintaining readability and clarity. Another small yet powerful step toward mastering array-based problems! 💻 🔥 #100DaysOfCode #LeetCode #Java #ProblemSolving #TwoPointers #DSA #CodingJourney

✅ Day 76 of LeetCode Medium/Hard Edition Today’s challenge was “Linked List in Binary Tree” — an elegant recursion and tree-traversal problem that blends linked list navigation with depth-first search on a binary tree 🌳🔗⚡💡 📦 Problem: You're given the head of a linked list and the root of a binary tree. Your task is to check whether the entire linked list appears as a downward path in the binary tree. A downward path means you may start at any node, but can only move to left or right children in each step. 🔗 Problem Link: https://lnkd.in/gwhvXVK4 ✅ My Submission: https://lnkd.in/gjqiBfJG 💡 Thought Process: A naive approach would try to follow the linked list from every tree node using repeated traversal — but without careful handling, this leads to redundant work. The optimized idea is to use DFS with two layers: 1️⃣ Search layer → Try starting the match from every node in the tree 2️⃣ Match layer → Check if the linked list matches a downward path from that node We define two functions: helper() → explores the tree to find a potential starting point match() → attempts to follow the linked list downward If at any node the values match and the entire list gets consumed, we return true. This structure avoids unnecessary recomputation and ensures clean, efficient traversal. ⚙️ Complexity: ⏱ Time: O(N × M) in the worst case (N = tree nodes, M = list length) 💾 Space: O(H) due to recursion stack (H = tree height) #LeetCodeMediumHardEdition #100DaysChallenge #DFS #BinaryTree #LinkedList #Java #DSA #ProblemSolving #LearnEveryday

🌟 Day 73 of 100 Days of Challenge 🌟 📌 LeetCode 220 — Contains Duplicate III Difficulty: 🟥 Hard | Language: Java ☕ Today’s problem was a tricky combination of index range and value range checks. The task was to determine if there exists a pair (i, j) such that: i ≠ j |i - j| ≤ indexDiff |nums[i] - nums[j]| ≤ valueDiff 🧠 Key Insight Instead of brute force (which is O(n²) ❌), we can use a sliding window + TreeSet approach: Maintain a window of size indexDiff. For each nums[i], find if there’s a number within [nums[i] - valueDiff, nums[i] + valueDiff]. TreeSet’s ceiling() function helps in efficient range searching. Slide the window forward by removing older elements. ⏱ Time Complexity: O(n log k) 💾 Space Complexity: O(k) where k = indexDiff ✨ Takeaway: This problem beautifully combines data structures (TreeSet) with sliding window, making it a great practice for hard-level problems. It sharpened my ability to handle both value-based and index-based constraints efficiently. #100DaysOfCode #Day71 #DSA #LeetCode #Java #ProblemSolving #TreeSet #SlidingWindow #CodingChallenge #HardProblem #LearningEveryday

🚀 Day 145 / 180 of #180DaysOfCode ✅ Revision Highlight: Today, I revisited LeetCode 35 — “Search Insert Position.” 🧩 Problem Summary: Given a sorted array of distinct integers, the task is to return the index of the target if it exists. Otherwise, return the position where it should be inserted to maintain order. The required time complexity is O(log n), making binary search the ideal approach. 💡 Core Concept: This is a classic binary search problem where the goal is not only to locate the target but also determine its correct insert position. It strengthens understanding of: Mid-point evaluation Range adjustments Handling edge cases (target smaller than all elements, larger than all, or between two values) 💻 Tech Stack: Java ⏱ Runtime: 0 ms (Beats 100%) 💾 Memory: 44.58 MB 🧠 Learnings: Revisited binary search fundamentals Reinforced the importance of boundary handling Great quick-revision problem for sharpening algorithmic precision 📈 Progress: This revision improved my command over binary search and edge-case reasoning — vital for tackling more complex algorithmic challenges. #LeetCode #Java #BinarySearch #DSA #ProblemSolving #CodingJourney #SoftwareEngineering #Optimization #180DaysOfCode #LogicBuilding #Revision

✅ Day 71 of LeetCode Medium/Hard Edition Today’s challenge was “Minimum Difficulty of a Job Schedule” — a classic Dynamic Programming partition problem that requires careful state management and optimal substructure thinking 🧩💪 📦 Problem: You’re given an array jobDifficulty and an integer d. Each job has a difficulty, and jobs must be done in order. You need to schedule all jobs over exactly d days, doing at least one job per day. The difficulty of a day is the maximum job difficulty of that day, and the goal is to minimize the sum of daily difficulties. If it’s impossible to schedule, return -1. 🔗 Problem Link: https://lnkd.in/gG37MbBc ✅ My Submission: https://lnkd.in/gSRD5Ftc 💡 Thought Process: This problem is all about dividing the sequence optimally. At every index, we decide how many jobs to assign to the current day — keeping track of: The maximum difficulty for that day The minimum total difficulty from the remaining jobs (using recursion) I implemented Top-Down DP (Memoization) to cache overlapping subproblems. dp[i][d] represents the minimum difficulty to schedule jobs starting from index i over d days. 🎯 Recurrence Relation: dp[i][d] = min( max(job[i...j]) + dp[j+1][d-1] ) for all j in [i, n - d] ⚙️ Complexity: ⏱ Time: O(n² * d) 💾 Space: O(n * d) #LeetCodeMediumHardEdition #100DaysChallenge #DynamicProgramming #Memoization #Java #ProblemSolving #DSA #CodingChallenge

📌 Day 38/100 – Make array elements equal to zero (LeetCode 3354) 🔹 Problem: Given an integer array nums, each element can be a number or zero. You need to find how many zeros in the array can be replaced by either +1 or -1 such that the total sum on both sides of that zero (left and right) remains balanced or differs by 1. 🔹 Approach: First, calculate the total sum s of all elements. Maintain a prefix sum l as you iterate. For each zero: If l * 2 == s, both +1 and -1 replacements are valid → add 2 to ans. If |l * 2 - s| == 1, only one replacement is valid → add 1 to ans. Return the total count ans. 🔹 Key Learning: Prefix sums simplify balance-based problems. Comparing 2 * prefixSum with total sum helps quickly check left-right equilibrium. 🔹 Complexity: Time: O(n) — single pass through array Space: O(1) — no extra storage used 🔹 Hashtags: #Day38Of100 #LeetCode3354 #100DaysOfCode #Java #DSA #ProblemSolving #PrefixSum #CodingChallenge

💻 Strengthening Problem-Solving Skills with LeetCode (Java) Recently explored a few interesting problems that focused on string manipulation, array traversal, and text formatting — each reinforcing clarity and precision in algorithmic thinking: 🔹 Text Justification Implemented a custom text alignment algorithm that evenly distributes spaces between words to fit a given line width. Approach: Greedy + StringBuilder Time Complexity: O(n) 🔹 Two Sum II – Input Array Is Sorted Solved using a two-pointer technique to efficiently find pairs that add up to a target value in a sorted array. Approach: Two Pointers Time Complexity: O(n) 🔹 Is Subsequence Checked whether one string is a subsequence of another using linear traversal and pointer comparison. Approach: Two Pointers Time Complexity: O(n) 🔹 Valid Palindrome Validated alphanumeric palindromes by filtering characters and comparing from both ends. Approach: String cleaning + two-pointer comparison Time Complexity: O(n) These problems helped sharpen my logic-building process and improved my confidence in designing efficient, readable solutions. #LeetCode #Java #ProblemSolving #DSA #Algorithms #Coding #SoftwareEngineering

📌 Day 13/100 - Valid Anagram (LeetCode 242) 🔹 Problem: Given two strings s and t, determine whether t is an anagram of s. An anagram is formed by rearranging the letters of one word to create another word — meaning both strings must have the same characters with the same frequency. 🔹 Approach: First, check if both strings are of equal length — if not, they can’t be anagrams. Convert both strings into character arrays. Sort both arrays and compare them using Arrays.equals(). If both sorted arrays are identical, the strings are anagrams. 🔹 Key Learning: Sorting can simplify comparison-based string problems. Always check base conditions (like length) to avoid unnecessary computation. This approach has a time complexity of O(n log n) due to sorting, which is efficient enough for this problem. Every solved challenge is another letter added to the dictionary of progress! 🚀 #100DaysOfCode #LeetCode #Java #ProblemSolving #DSA #CodingJourney #Consistency