Mastering Backtracking: Combination Sum Problem

Day 09 of #50DaysOfLeetCode Challenge Just tackled the "Combination Sum" problem! This was a fantastic exercise in backtracking. The challenge is to find all unique combinations of numbers that sum up to a specific target, with the twist that you can use the same number multiple times. Key Insights: Backtracking Power: It’s all about exploring every possible path and "backtracking" as soon as the sum exceeds the target. State Space Tree: Visualizing how the recursion branches out helped me understand how to avoid duplicate combinations while allowing multiple uses of the same element. Decision Making: Learning when to include an element and when to move to the next index is crucial for optimizing the search. Each day, the logic gets sharper and the problems get more interesting! #DataStructures #Algorithms #CodingJourney #Java #Backtracking #LeetCode #ProblemSolving #SoftwareEngineering

Day 20 of my #30DayCodeChallenge: Efficiency through Pruning! Today's challenge was Word Search II-a complex puzzle that tests how you manage massive search spaces. The Logic: 1. Trie Integration: I stored the dictionary in a Trie to check prefixes in O(1) time. 2. DFS & Backtracking: Explored the grid cell by cell, but with a twist... 3. Intelligent Pruning: If a path doesn't match a Trie prefix, the search stops immediately. This turns an exponential problem into something much more manageable. Coding isn't just about finding the answer; it's about finding it before your timer runs out! #Java #DataStructures #Backtracking #Trie #Algorithms #CleanCode #150DaysOfCode

🚀 Day 49 of #100DaysOfCode ✅ Solved: Find the Difference 🔍 What I did: Used a clever XOR bit manipulation technique to identify the extra character between two strings efficiently. 💡 Key Learning: XOR cancels out identical characters Helps find unique elements in linear time Clean and optimal approach without extra space ⚡ Time Complexity: O(n) 📦 Space Complexity: O(1) 🎯 Takeaway: Sometimes the best solutions are not obvious — learning small tricks like XOR can make a big difference in problem solving. #Java #LeetCode #ProblemSolving #CodingJourney #100DaysChallenge #DataStructures #Algorithms

Day 23 of my #30DayCodeChallenge: The Art of Pruning! The Problem: Permutations II. Generating all unique permutations of a collection that contains duplicates. The challenge isn't just finding the arrangements, but ensuring we don't repeat work or results. The Logic: This problem is a deep dive into Backtracking with a strategic Pruning layer: 1. The Frequency/State Tracking: Since we have duplicate numbers, we can't just rely on the values themselves. I used a vis [] (visited) boolean array to keep track of which specific index in the array is currently being used in our recursion tree. 2. Sorting for Symmetry Breaking: Before starting the recursion, sorting the array is the secret sauce. By grouping identical numbers together, we can easily identify when we are about to make a "dur"-ate choice." 3. Backtracking: Standard push, recurse, and pop. We explore every valid path, then "undo" our choice by setting vis [j] = false to backtrack and try the next possibility. One step closer to mastery. The logic is getting sharper! Onward to Day 24! #Java #Algorithms #DataStructures #Backtracking #LeetCode #150DaysOfCode #SoftwareEngineering

Day 16 of my #30DayCodeChallenge: Navigating the Twist! The Problem: Search in Rotated Sorted Array. The Logic: While a standard Binary Search assumes a fully linear sequence, a rotated array introduces a "break point." The key is realizing that at any given mid-point, at least one half of the array must be sorted. 1. Identify the Sorted Half: In every iteration, I compare nums [left] with nums [mid]. If nums [left] <= nums [mid], the left side is sorted. Otherwise, the right side is sorted. 2. Range Check: Instead of searching blindly, I check if the target actually lies within the bounds of that sorted half. 3. The Result: By consistently discarding half of the search space based on these sorted properties, we pinpoint the target index or return -1 if it doesn't exist. Cracking the code, one rotation at a time. Onward to Day 17! #Java #Algorithms #DataStructures #BinarySearch #ProblemSolving #150DaysOfCode #SoftwareEngineering

🚀 100 Days of Code Day-25 LeetCode Problem Solved: Reverse Nodes in k-Group I recently worked on a Linked List problem that focuses on reversing nodes in groups of size k while preserving the remaining structure if the group size is less than k. 🔹 Strengthened my understanding of pointer manipulation 🔹 Improved problem decomposition skills 🔹 Practiced recursive thinking for efficient implementation 💡 Key takeaway: Breaking complex problems into smaller, manageable parts significantly simplifies the solution approach. Continuing to build consistency in problem-solving and deepen my understanding of Data Structures & Algorithms. #LeetCode #DataStructures #Algorithms #Java #ProblemSolving #SoftwareDevelopment

🚀 #Day54 of #100DaysDSAChallenge Solved #LeetCode160: Intersection of Two Linked Lists The problem asks us to find the node where two singly linked lists intersect. 🔹 Approach: 🔸 Brute Force Store nodes of one list in a hashmap/set and check while traversing the second list. ⏱️ Time: O(n + m) | 📦 Space: O(n) 🔸 Better Find lengths of both lists, move the longer list ahead by the difference, then traverse together to find intersection. ⏱️ Time: O(n + m) | 📦 Space: O(1) 🔸 Optimal Use two pointers and switch heads when reaching null so both traverse equal distance and meet at intersection. ⏱️ Time: O(n + m) | 📦 Space: O(1) 💡 Great example of improving from extra space → alignment → elegant pointer trick. 🔗 Github repo: https://lnkd.in/g_rSFCh8 #100DaysOfDSA #DSA #LeetCode #Java #Algorithms #DataStructures #KunalKushwaha #Striver #GeeksForGeeks #ProblemSolving #CodingJourney #LearningInPublic #InterviewPrep #PlacementPreparation 🚀

🚀 LeetCode Challenge 10/50 🔍 Problem: Merge Sorted Array Today’s problem focused on efficiently merging two sorted arrays without using extra space. 💡 Approach: I used the Two Pointer technique (from the end): Started comparing elements from the back of both arrays Placed the larger element at the end of nums1 Continued this process until all elements were merged ⚡ This approach avoids unnecessary shifting and works in-place. 📊 Complexity Analysis: Time Complexity: O(m + n) Space Complexity: O(1) 📚 Key Learning: Thinking from the end can simplify problems and avoid extra operations. Two-pointer technique is extremely useful for array manipulation problems. Consistency is building confidence 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

Another day of showing up, learning, and getting sharper 💻🔥 Solved Boundary Traversal of Binary Tree today and got it accepted with 100% accuracy (1111/1111 test cases passed) 💯✅ This was a really good problem for understanding how to break one tree traversal into multiple smaller traversals and combine them cleanly 🌳🧠 🔍 Problem Insight: The goal was to print the boundary nodes of a binary tree in anti-clockwise direction 🔄🌳 That means covering: 👉 Root node 👉 Left boundary (excluding leaf nodes) 👉 All leaf nodes (left to right) 🍃 👉 Right boundary (excluding leaf nodes, in reverse) 🧠 My Approach: Instead of forcing everything into one traversal, I split the problem into 3 clean helper functions ✨ 👉 Left Boundary Traversal Traversed the left side while skipping leaf nodes ⬅️🌿 👉 Leaf Node Traversal Collected all leaf nodes using DFS from left to right 🍃 👉 Right Boundary Traversal Traversed the right side and added nodes in reverse order to maintain anti-clockwise flow ➡️🔄 Then combined everything in sequence to build the final boundary traversal 🎯 ✨ Why this approach works well: ✔ Breaks a complex problem into manageable parts 🧩 ✔ Avoids duplicate leaf nodes 🚫🍃 ✔ Clean recursive design 🌳 ✔ Easy to debug and reason about 🧠 📊 Complexity: ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(h) recursion stack 💡 Key Takeaway: Tree problems often become much simpler when you stop thinking in terms of “one big traversal” and instead split them into smaller focused traversals 🎯 Decompose well → solve cleanly 🚀 One more tree problem down, many more to go 🌳💪🔥 #BinaryTree #Trees #TreeTraversal #Java #Recursion #DFS #DataStructures #DSA #ProblemSolving #CodingJourney #100DaysOfCode #SoftwareEngineering #Programming 💻🌳🚀

🚀 Day 81 – DSA Journey | Binary Tree Inorder Traversal Continuing my daily DSA practice, today I explored tree traversal and how stacks can simulate recursion. 📌 Problem Practiced: Binary Tree Inorder Traversal (LeetCode 94) 🔍 Problem Idea: Traverse a binary tree in inorder sequence — Left → Root → Right — and return the values of nodes. 💡 Key Insight: Instead of recursion, we can use a stack to iteratively traverse the tree by going as left as possible, then processing nodes and moving right. 📌 Approach Used: • Use a stack to simulate recursion • Start from root and go to the leftmost node • Push nodes while moving left • Pop from stack, process the node • Move to the right subtree and repeat 📌 Concepts Strengthened: • Tree traversal (Inorder) • Stack usage in trees • Iterative vs recursive approaches • Understanding tree structure ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔥 Today’s takeaway: Recursion can always be converted into iteration using stacks — understanding this gives more control over traversal logic. On to Day 82! 🚀 #Day81 #DSAJourney #LeetCode #BinaryTree #Stack #Java #ProblemSolving #Coding #LearningInPublic #Consistency