Efficiency through Pruning: Trie & Backtracking in Word Search II

🚀 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

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 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

🚀 LeetCode Challenge 22/50 💡 Approach: Space-Optimized Dynamic Programming A robot moves only RIGHT or DOWN on an m×n grid. How many unique paths reach the bottom-right corner? Recursion explodes exponentially — DP solves it beautifully, and we can do even better by ditching the full 2D grid! 🔍 Key Insight: → Every cell's paths = paths from ABOVE + paths from LEFT → First row & first column always have exactly 1 path each → We only ever need the CURRENT and PREVIOUS row → So one 1D array updated in-place is enough! 📈 Complexity: ❌ Recursion → O(2^(m+n)) Time ❌ 2D DP → O(m×n) Time, O(m×n) Space ✅ 1D DP → O(m×n) Time, O(n) Space   Same speed, fraction of the memory! DP teaches us to build solutions from the ground up — one step, one row, one decision at a time. 🤖 #LeetCode #DSA #DynamicProgramming #Java #ADA #PBL2 #LeetCodeChallenge #Day22of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #UniquePaths

🚀Day 29 Solved LeetCode Problem #129 – Sum Root to Leaf Numbers Today I worked on a Binary Tree problem that focuses on DFS traversal and number formation from root-to-leaf paths. 🌳 🔹 Problem: Given a binary tree where each node contains digits (0–9), every root-to-leaf path forms a number. The goal is to calculate the total sum of all these numbers. 🔹 Example: Tree: [1,2,3] Paths: 1 → 2 = 12 1 → 3 = 13 Total Sum = 12 + 13 = 25 🔹 Approach: ✔ Use Depth First Search (DFS) ✔ Build the number while traversing the tree ✔ Multiply previous value by 10 and add the current digit ✔ When reaching a leaf node, add the number to the total sum ⏱ Time Complexity: O(n) 📦 Space Complexity: O(h) 💡 Key Learning: This problem helped strengthen my understanding of Binary Tree traversal and how recursive DFS can be used to carry state across nodes. Excited to keep improving my problem-solving skills! 💻🔥 #leetcode #datastructures #algorithms #java #binarytree #coding #softwaredeveloper #codingjourney

🚀 Solved LeetCode 2515 – Shortest Distance to Target String in a Circular Array Today I tackled an interesting problem that highlights the importance of handling circular data structures efficiently. 🔍 Problem Insight: Given a circular array of words, a target string, and a starting index, the goal is to find the minimum number of steps required to reach the target by moving either left or right. 💡 Key Learnings: Circular arrays require thinking beyond linear traversal Always consider both directions (forward & backward) Optimizing distance using min(distance, n - distance) is the key trick Simple logic + correct observation = optimal solution ⚙️ Approach Used: Traverse the array to find all occurrences of the target Calculate distance from the starting index Take the minimum considering circular movement 📈 Complexity: Efficient O(n) solution with constant space 🔥 Takeaway: This problem reinforced how small tweaks (like circular behavior) can change the entire approach. A great example of combining logic + observation for clean and optimal solutions. #LeetCode #Algorithms #ProblemSolving #CodingJourney #Java #DataStructures #CompetitiveProgramming

Day 19 of my #30DayCodeChallenge: Mastering Backtracking! The Problem: Combination Sum. Finding all unique combinations of candidates that sum up to a specific target, where each number can be used an unlimited number of times. The Logic: This problem is a perfect example of how Recursion and Backtracking allow us to explore multiple paths while pruning the ones that don't lead to a solution. 1. State-Space Exploration: I used a recursive approach to explore every possible combination. By passing the current index forward, we ensure we don't pick the same set of numbers in a different order, keeping the results unique. 2. The "Unlimited" Choice: Unlike some problems where you move to the next element immediately, here we have the option to stay on the same element to achieve the "unlimited times" constraint-as long as the remaining target allows it. 3. Backtracking & Pru.. If the current sum exceeds the target. we ston exploring that branch (Backtrack). This keeps the algorithm efficient even as the depth of the recursion grows. One more step toward algorithmic mastery. Onward to Day 20! #Java #Algorithms #DataStructures #Backtracking #ProblemSolving #150DaysOfCode #SoftwareEngineering #LeetCode

Day 27 of my #30DayCodeChallenge: The Efficiency of Binary Exponentiation! The Problem: Pow(x, n). Implementing the power function to calculate x". While it sounds simple, the challenge lies in handling large exponents (up to 231 - 1) and negative powers without hitting time limits or overflow. The Logic: This problem is a classic example of Divide and Conquer optimized through Binary Exponentiation (also known as Exponentiation by Squaring): 1. Bitwise Breakdown: Instead of multiplying x by itself n times (O(n)), we decompose n into powers of 2. For example, x13 is x8. x4. x¹. This brings our complexity down to O(log n). 2. The Iterative Jump: In every iteration of the loop, we square the current base (x = x x). If the current bit of n is 1 (checked via n & 1), we multiply our result by the current base. 3. Handling the Edge Cases: * Negative Exponents: If n is negative, we calculate xI" and then take the reciprocal (1/result). Overflow: We use a long for n during calculation to avoid overflow when converting -2, 147, 483, 648 to a positive value. The Calculation: By halving the power at each step, we transform a task that could take 2 billion operations into one that takes just 31. One step closer to mastery. Onward to Day 28! #Java #Algorithms #DataStructures #BinaryExponentiation #ProblemSolving #150DaysOfCode #SoftwareEngineer

💡 Day 57 of LeetCode Problem Solved! 🔧 🌟 Maximum Distance Between a Pair of Values 🌟 🔗 Solution Code: https://lnkd.in/gSP_QePE 🧠 Approach:  • Two-Pointer Strategy: Maintain two indices (i for nums1 and j for nums2) to scan both non-increasing arrays in a single efficient pass. • Greedy Search: If nums1[i] <= nums2[j], calculate j - i and expand j to find the maximum possible distance. If the value in nums1 is too large, move i forward. ⚡ Key Learning:  • Leveraging the non-increasing nature of arrays with two pointers eliminates the need for nested loops, reducing complexity from O(N^2) to linear O(N+M). ⏱️ Complexity:  • Time: O(n + m) • Space: O(1) #LeetCode #Java #DSA #ProblemSolving #Consistency #100DaysOfCode #CodingJourney #Algorithms #TwoPointers

💡 Day 56 of LeetCode Problem Solved! 🔧 🌟 Mirror of an Integer 🌟 🔗 Solution Code: https://lnkd.in/gvaEY4Sw 🧠 Approach: • Digit Extraction & Reversal Extract digits from right to left using modulo (% 10) and rebuild the reversed number dynamically. • Calculate the absolute difference abs(n - reversed) at the end to find the mirror distance. ⚡ Key Learning: • Mastering number manipulation with fundamental math operators (% and /) is a game-changer for processing integers efficiently without relying on space-consuming String conversions. ⏱️ Complexity: • Time: O(log₁₀(n)) (proportional to the number of digits)  • Space: O(1) #LeetCode #Java #DSA #ProblemSolving #Consistency #100DaysOfCode #CodingJourney #MathLogic #DataStructures