How to Solve House Robber III with DFS and DP

🎯 LeetCode Daily – Combination Sum IV (Day 125) Today’s problem was a powerful exploration of Dynamic Programming with sequence-based combinations - Combination Sum IV. ✅ My Approach: 🔹 Problem – Combination Sum IV: • The goal was to find the number of possible ordered combinations that sum up to a given target using elements from an array. • Implemented Memoization (Top-Down DP) to recursively explore all ways to reach the target, caching results to prevent recomputation. • Then optimized with Tabulation (Bottom-Up DP), where each state dp[i] represents the number of combinations that sum to i. • For every value from 0 to target, iterated through all numbers and accumulated valid combinations. 🧠 Key Insight: Unlike the traditional Subset Sum or Coin Change problems, this problem treats order as significant, making it a classic case of permutation-based DP. The key is understanding how smaller sub-targets build up to form the total - a perfect demonstration of the power of recursive relationships. 📊 Time Complexity: O(N × Target) 📦 Space Complexity: O(Target) #LeetCode #DSA #DynamicProgramming #Combinatorics #ProblemSolving #DailyCoding #LearningInPublic #Day125

Leetcode problem solving day 88 today i solved problem number 222. Count Complete Tree Nodes link to problem - https://lnkd.in/gWVKj_hb below is my approch Approach 1: Linear Time count nodes recursively one by one. class Solution {  public int countNodes(TreeNode root) {   return root != null ? 1 + countNodes(root.right) + countNodes(root.left) : 0;  } } Time complexity : O(N). Space complexity :O(logN) Approach 2: Binary search Return 0 if the tree is empty. Compute the tree depth d. Return 1 if d == 0. The number of nodes in all levels but the last one is 2 to the power d−1. The number of nodes in the last level could vary from 1 to 2 to the power d. Enumerate potential nodes from 0 to 2 to the power d−1. and perform the binary search by the node index to check how many nodes are in the last level. Use the function exists(idx, d, root) to check if the node with index idx exists. Use binary search to implement exists(idx, d, root) as well. Return 2 to the power d−1 + the number of nodes in the last level. Time complexity :O(log square N) Space complexity : O(1)     #DSA  #Programming  #LeetCode #ProblemSolving #CodingJourney #TechCommunity   

Today I solved the Reverse Integer problem on LeetCode — a classic challenge that tests how well you handle numeric operations and overflow conditions in a constrained environment. 🧩 Problem Summary: Given a signed 32-bit integer x, return the integer obtained by reversing its digits. If reversing x causes it to go outside the 32-bit signed integer range [-2³¹, 2³¹ - 1], return 0. ⚙️ Approach: Initialize revNum = 0 to store the reversed number. Extract the last digit of n using dig = n % 10. Before updating, check for overflow: If revNum > INT_MAX / 10 or revNum < INT_MIN / 10, return 0. Append the digit: revNum = revNum * 10 + dig. Remove the last digit from the original number: n = n / 10. Continue until all digits are processed. Return the final reversed integer. This ensures safety against integer overflow without using 64-bit integers — a key constraint of the problem. ⏱️ Time Complexity: O(log₁₀(n)) → Each iteration processes one digit. 💾 Space Complexity: O(1) → Constant extra space used. 🧠 Concepts Practiced: Integer manipulation Overflow handling Edge case analysis Bit-width constraints #LeetCode #Cplusplus #DSA #ProblemSolving #CodingJourney #CodeWithConsistency #Programming #Learning

🚀 Day 63 of #100DaysOfCode — LeetCode 1799: Maximize Score After N Operations (Hard) My Submission:https://lnkd.in/gDTGaHA5 Today’s problem focused on applying bitmask dynamic programming to optimize pair selection in a sequence of operations. The challenge was to maximize the total score obtained from pairing numbers, where each operation contributes a score of i × gcd(x, y). Since elements are removed after pairing, an efficient way to explore valid combinations was key. 💡 Approach: I implemented a recursive + memoized DP solution using bitmasking: Each bit in the mask represents whether an element has been used. For each operation, I iterated over all possible pairs of unused elements (i, j) and computed the score as (operation_index + 1) * gcd(nums[i], nums[j]). The recursive function explores all valid pairings, while memoization (dp[mask][index]) ensures overlapping subproblems are computed once. This approach efficiently handles up to 14 elements (since n ≤ 7) while ensuring the optimal global result. ⏱️ Time Complexity: O((2n)² × 2^(2n)) 💾 Space Complexity: O(2^(2n) × n) A great exercise in bitmask optimization and recursive state management — one of those problems that really sharpen implementation clarity. #LeetCode #DynamicProgramming #Bitmasking #ProblemSolving #Cplusplus #100DaysOfCode #LearningEveryday #AlgorithmDesign

Solved Pow(x, n) (LeetCode #50) recently, and this one turned out to be more than just another coding exercise. 💡 32-bit Integer Insights: 🔹 An integer uses 32 bits: 1 bit is for the sign (positive/negative), and 31 bits store the actual value. 🔹 Negative values: Represented from -1 to -2,147,483,648 (a total of 2,147,483,648 values). 🔹 Positive values: From 1 to 2,147,483,647 (a total of 2,147,483,647 values), since zero also needs a spot. 🔹 That’s why the maximum positive (2,147,483,647) and maximum negative (-2,147,483,648) values in 32-bit integers don’t match. 🔀 My Fix: Convert n to a long before using recursion. This avoids overflow issues and ensures the code works for all edge cases. This challenge not only strengthened my understanding of binary exponentiation, but also revised those crucial details about 32-bit integer representation. #LeetCode #DSA #Programming #100DaysOfCode #BinaryExponentiation #TechLearning #CodingJourney #PGPByAnchal

💯 Day 7/100: Dynamic Programming — LeetCode 474 Today’s challenge was a classic optimization puzzle: selecting the largest subset of binary strings under strict limits on the number of 0s and 1s. It’s essentially a two-dimensional knapsack problem, where each string consumes a portion of your limited resources. The key breakthrough was realizing that you need to traverse the DP table in reverse to preserve state dependencies. Each update reflects the best outcome when including a new string, without overwriting previous possibilities. This problem sharpened my understanding of multi-dimensional constraints and reinforced the importance of state reuse in dynamic programming. It’s a great reminder that even medium-difficulty problems can hide deep algorithmic insights. Onward to Day 8 — the grind continues. #100DaysOfCode #LeetCode #DynamicProgramming #TechJourney #ScarCodes #ProblemSolving #CodeChallenge #SoftwareEngineering

🚀 #Day57 of #100DaysOfLeetCodeHard 📘 Problem: [LeetCode 2547 – Minimum Cost to Split an Array] My Submission:https://lnkd.in/gB2aQ9TS This one was a really interesting DP + preprocessing problem that tested both efficiency and clarity of thought. 💡 Approach: The key idea was to precompute the cost of every possible subarray [i...j], where cost represents the number of elements that appear more than once (the trimmed part). Once precomputed, the problem transforms into a simple Dynamic Programming formulation: dp[i] = min( k + cost[i][j] + dp[j+1] ) for all j ≥ i This way, we can efficiently find the optimal points to split the array, minimizing the total cost. Given the constraints (n ≤ 1000), an O(n²) preprocessing and DP approach works perfectly. 🧮 Complexity: Time: O(n²) Space: O(n²) A neat problem that beautifully combines frequency tracking, preprocessing, and classic DP — a great example of how strong intuition can simplify what initially looks intimidating. #100DaysOfLeetCodeHard #Day57 #LeetCode #DynamicProgramming #ProblemSolving #DSA #CompetitiveProgramming #Precomputation

.NET Exception Handling: Preserve StackTrace with throw, avoid throw ex; A simple but important detail you must never forget! #Csharp #NET #ExceptionHandling #Development #StackTrace #Throw

 Day 6 – LeetCode Challenge Today, I solved Problem #128: “Longest Consecutive Sequence” using C++. 🔍 Problem Overview: The task is to find the length of the longest consecutive elements sequence in an unsorted integer array. The key challenge is to ensure the solution works in O(n) time complexity. 💡 Approach: To achieve linear time, I used an unordered_set to quickly check if a number exists. For each number, I only begin counting a sequence when it is the start of a new streak (i.e., (num - 1) does not exist in the set). This ensures each number is processed only once. 🧠 Algorithm Design: Insert all elements into an unordered_set for O(1) average lookups. For every number, check if it's the start of a sequence. If yes, count forward (num + 1, num + 2, ... ) while elements exist in the set. Track and update the maximum streak length. ⏱ Time Complexity: O(n) 📌 Space Complexity: O(n) #LeetCode #CPlusPlus #DSA #100DaysOfCode #ProblemSolving #Algorithms #CodingChallenge #TechCommunity #GeetaUniversity