Day 11 LeetCode Challenge: Permutations with Backtracking

✅ Day 39 of 100 Days LeetCode Challenge Problem: 🔹 #114 – Flatten Binary Tree to Linked List 🔗 https://lnkd.in/g6xn2K3g Learning Journey: 🔹 Today’s problem focused on transforming a binary tree into a flattened linked list in-place. 🔹 I used an iterative approach, modifying pointers while traversing the tree. 🔹 For each node with a left subtree, I found the rightmost node of that subtree and connected it to the current node’s right subtree. 🔹 Then, I moved the left subtree to the right and continued traversal. Concepts Used: 🔹 Binary Trees 🔹 Tree Traversal 🔹 Pointer Manipulation 🔹 In-place Modification Key Insight: 🔹 Tree restructuring problems often rely on careful pointer adjustments. 🔹 Finding the predecessor (rightmost node of left subtree) helps preserve traversal order. 🔹 Iterative solutions can avoid recursion and reduce extra space usage. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 13 of 100 Days LeetCode Challenge Problem: 🔹 #90 – Subsets II 🔗 https://lnkd.in/gCyD9UNb Learning Journey: 🔹 Today’s problem was similar to yesterday’s (#78 – Subsets), but this time the array could contain duplicates, so we had to ensure the solution set did not contain duplicate subsets. 🔹 I approached it using backtracking, again making a binary decision at each index: include or exclude the current element. 🔹 To handle duplicates, I sorted the array first and skipped duplicate elements at the same recursion level, preventing repeated subsets. 🔹 Copying the current solution at each step preserves the subset before backtracking continues. Concepts Used: 🔹 Backtracking 🔹 Recursion 🔹 Depth-First Search (DFS) 🔹 Handling Duplicates Key Insight: 🔹 Sorting and carefully skipping duplicates is essential when generating unique subsets. 🔹 Subset problems map naturally to an include/exclude decision tree. 🔹 Backtracking remains a clean way to explore all combinations, even with duplicate elements. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 14 of 100 Days LeetCode Challenge Problem: 🔹 #39 – Combination Sum 🔗 https://lnkd.in/gZc8SUvr Learning Journey: 🔹 Today’s problem focused on finding all unique combinations of numbers that sum up to a given target. 🔹 I solved it using backtracking, where at each step I had two choices: include the current number or move to the next candidate. 🔹 Unlike subset problems, the same element can be reused multiple times, so the recursive call stays on the same index when including an element. 🔹 The recursion stops when the total exceeds the target or when a valid combination is found. Concepts Used: 🔹 Backtracking 🔹 Recursion 🔹 Depth-First Search (DFS) 🔹 Pruning Recursive Paths Key Insight: 🔹 Backtracking is especially powerful for constraint-based problems like sum and combination generation. 🔹 Pruning paths early (when the sum exceeds the target) significantly improves efficiency. 🔹 Understanding how index movement controls reuse of elements is key to mastering combination problems. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 12 of 100 Days LeetCode Challenge Problem: 🔹 #78 – Subsets 🔗 https://lnkd.in/gazZukB6 Learning Journey: 🔹 Today’s problem was about generating all possible subsets (the power set) of a given array. 🔹 I approached it using backtracking, making a binary decision at each index: include or exclude the current element. 🔹 The recursion explores both paths systematically, ensuring no subset is missed. 🔹 Copying the current solution at the base case preserves the state before backtracking continues. Concepts Used: 🔹 Backtracking 🔹 Recursion 🔹 Depth-First Search (DFS) 🔹 Power Set Generation Key Insight: 🔹 Subset problems naturally map to a include/exclude decision tree. 🔹 Backtracking provides a clean and intuitive way to explore all combinations. 🔹 Understanding recursion flow is crucial for mastering combinatorial problems. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 15 of 100 Days LeetCode Challenge Problem: 🔹 #40 – Combination Sum II 🔗 https://lnkd.in/g-w7rAcg Learning Journey: 🔹 Today’s problem was an extension of yesterday’s Combination Sum, but with an added constraint: each number can be used only once, and the input may contain duplicates. 🔹 I solved it using backtracking combined with sorting to group duplicate values together. 🔹 At each recursion level, I iterated through the candidates and skipped duplicate elements at the same level to avoid generating repeated combinations. 🔹 The recursion moves to the next index after choosing a number, ensuring elements are not reused. Concepts Used: 🔹 Backtracking 🔹 Recursion 🔹 Depth-First Search (DFS) 🔹 Handling Duplicates 🔹 Pruning Recursive Paths Key Insight: 🔹 Sorting is crucial when dealing with duplicate candidates in combination problems. 🔹 Skipping duplicates at the same recursion level prevents repeated combinations without missing valid ones. 🔹 Small changes in index movement can completely change problem constraints and solution behavior. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 20 of 100 Days LeetCode Challenge Problem: 🔹 #234 – Palindrome Linked List 🔗 https://lnkd.in/g8yA6gDH Learning Journey: 🔹 Today’s problem focused on checking whether a singly linked list is a palindrome. 🔹 I traversed the linked list and converted its values into a string representation. 🔹 After building the sequence, I compared it with its reverse to determine if the list reads the same forward and backward. 🔹 This approach provides a clear and straightforward way to validate palindromic order. Concepts Used: 🔹 Linked Lists 🔹 String Manipulation 🔹 Traversal 🔹 Two-Pointer Logic (conceptual via reversal) Key Insight: 🔹 Sometimes a simple transformation can make a problem easier to solve. 🔹 Converting a linked list into a linear structure allows reuse of familiar palindrome-check techniques. 🔹 While this approach uses extra space, it is effective and easy to reason about. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 25 of 100 Days LeetCode Challenge Problem: 🔹 #198 – House Robber 🔗 https://lnkd.in/gNEG2NE4 Learning Journey: 🔹 Today’s problem focused on maximizing the amount of money that can be robbed without alerting the police by robbing adjacent houses. 🔹 I solved it using Dynamic Programming by keeping track of two states: robbing the current house or skipping it. 🔹 At each step, the decision is based on the maximum profit from previous houses. 🔹 This approach avoids recursion and efficiently computes the result in a single pass. Concepts Used: 🔹 Dynamic Programming 🔹 State Transition 🔹 Iterative Optimization 🔹 Space Optimization Key Insight: 🔹 Problems involving optimal choices often reduce to tracking previous states. 🔹 Using only two variables is sufficient to represent the entire DP state. 🔹 This results in an efficient solution with linear time and constant space complexity. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 38 of 100 Days LeetCode Challenge Problem: 🔹 #323 – Number of Connected Components in an Undirected Graph 🔗 https://lnkd.in/gRVWsWgZ Learning Journey: 🔹 Today’s problem focused on counting connected components in an undirected graph. 🔹 I represented the graph using an adjacency list built from the edge list. 🔹 Using Depth-First Search (DFS), I explored all nodes reachable from a starting node. 🔹 Each new DFS traversal from an unvisited node indicates a new connected component. Concepts Used: 🔹 Depth-First Search (DFS) 🔹 Graph Representation (Adjacency List) 🔹 Connected Components 🔹 Graph Traversal Key Insight: 🔹 Graph problems often reduce to exploring connectivity between nodes. 🔹 Tracking visited nodes prevents redundant traversals. 🔹 Iterative DFS using a stack provides a clean and efficient solution. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 24 of 100 Days LeetCode Challenge Problem: 🔹 #70 – Climbing Stairs 🔗 https://lnkd.in/gXJvMedQ Learning Journey: 🔹 Today’s problem focused on finding the number of distinct ways to climb a staircase when you can take either 1 or 2 steps at a time. 🔹 I observed that the problem follows a Fibonacci-like pattern, where each step depends on the previous two steps. 🔹 Instead of using recursion, I implemented an iterative Dynamic Programming approach to optimize performance. 🔹 This solution efficiently computes the result using constant space. Concepts Used: 🔹 Dynamic Programming 🔹 Fibonacci Sequence 🔹 Iterative Optimization 🔹 Space Optimization Key Insight: 🔹 Many counting problems reduce to recognizing a recurrence relation. 🔹 Avoiding recursion helps prevent unnecessary stack usage. 🔹 Using constant space makes the solution more efficient and scalable. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity

✅ Day 34 of 100 Days LeetCode Challenge Problem: 🔹 #38 – Count and Say 🔗 https://lnkd.in/gZKE3maw Learning Journey: 🔹 Today’s problem focused on generating the nth term of the Count and Say sequence. 🔹 Each term is built by reading the previous term and describing consecutive digits using Run-Length Encoding (RLE). 🔹 I iteratively generated each sequence starting from "1" until reaching the desired term. 🔹 A helper function handles counting consecutive characters and forming the next sequence. Concepts Used: 🔹 String Manipulation 🔹 Run-Length Encoding (RLE) 🔹 Iterative Simulation 🔹 Pattern Recognition Key Insight: 🔹 Many sequence problems rely on recognizing and encoding patterns. 🔹 Breaking the logic into a helper function improves readability and correctness. 🔹 Iterative construction avoids unnecessary recursion and keeps the solution efficient. #LeetCode #DataStructures #Algorithms #CodingInterview #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #BackendDevelopment #InterviewPreparation #TechCommunity