Solved LeetCode 1799 with bitmask DP: Maximize Score After N Operations

🚀 LeetCode POTD — 474. Ones and Zeroes 🎯 Difficulty: Medium | Topics: Dynamic Programming, 0/1 Knapsack 🔗 Solution Link: https://lnkd.in/gscqurzi Today’s #LeetCode Problem of the Day was a classic 0/1 Knapsack variation — and a great reminder of how dynamic programming helps balance multiple constraints efficiently. The task was to find the largest subset of binary strings that can be formed with at most m zeros and n ones. 🧠 My Approach: For each string, count the number of 0s and 1s. Use a 2D DP array (dp[m+1][n+1]), where dp[i][j] represents the maximum subset size possible using i zeros and j ones. Traverse in reverse (to avoid recomputation) and update using: dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1); The final answer is dp[m][n]. 📈 Complexity: Time: O(len(strs) × m × n) Space: O(m × n) 💡 Takeaway: Dynamic Programming is all about breaking problems into smaller overlapping subproblems — once you see that, even “complex” constraints start falling into place logically. #LeetCode #ProblemOfTheDay #DynamicProgramming #Knapsack #DSA #CodingChallenge #ProblemSolving #C++ #SoftwareEngineering #CodingJourney #100DaysOfCode #LearningInPublic #TechCommunity

📅 October 29, 2025 🧩 Problems Solved: 🔹 House Robber III | Binary Tree, DFS, Dynamic Programming | Medium The key to simplifying this problem is to return two states for every node: 1️⃣ The maximum sum including the current node. 2️⃣ The maximum sum excluding the current node. At each recursive call: For the include case, we add the node’s value plus the sums of left and right subtrees excluding their roots. For the exclude case, we take the maximum of both states from the left and right subtrees, since we can freely choose whether to include or skip them. Finally, the answer is the maximum between the include and exclude sums at the root. ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(n) https://lnkd.in/gSqTztRw 💡 Key Takeaways: • Always think in “states” when dealing with tree DP — defining clear include/exclude relationships often simplifies recursive logic. • Returning multiple values (as a pair or struct) from recursion can greatly reduce redundant recomputation and improve clarity. #LeetCode #100DaysOfCode #DSA #CodingJourney #Cplusplus #ProblemSolving #TechPrep #BinaryTree #DynamicProgramming

🚀 LeetCode POTD — 2536. Increment Submatrices by One 🎯 Difficulty: Medium | Topics: 2D Difference Array, Prefix Sums, Matrix Manipulation 🔗 Solution Link: https://lnkd.in/gpjg6t5w Today’s #LeetCode Problem of the Day was a classic 2D difference array question — simple once you recognize the pattern, but extremely efficient compared to brute-force updates. We’re given an n × n zero matrix and multiple queries, where each query asks us to increment every element in a submatrix by 1. Updating each cell one-by-one would be too slow, so difference-array logic makes the solution clean and optimal. 🧠 My Approach: For each query [x, y, a, b], instead of updating the entire submatrix, update only the start and end boundaries using difference marks: matrix[i][y] += 1; if (b + 1 < n) matrix[i][b + 1] -= 1; Loop from row x to a and apply these boundary updates. After processing all queries, run a prefix sum row-wise to build the final matrix. This reduces the complexity drastically and leverages the power of prefix operations. 📈 Complexity: Time: O(n² + q × submatrix_height) Space: O(n²) 💡 Takeaway: Difference arrays (1D or 2D) are among the most elegant techniques to convert repeated updates into boundary operations — a pattern that appears often in competitive programming and system-level problems. #LeetCode #ProblemOfTheDay #DSA #Matrix #PrefixSum #DifferenceArray #CodingChallenge #Programming #SoftwareEngineering #CodingJourney #100DaysOfCode #TechCommunity

✨ Day 49 of 50 Days Challenge ✨ Solved LeetCode 115: Distinct Subsequences (Hard) 👉 Problem Statement: Given two strings s and t, return the number of distinct subsequences of s that equal t. A subsequence is formed by deleting some (or none) characters without changing the relative order of the remaining characters. 📌 Examples: Input: s = "rabbbit", t = "rabbit" Output: 3 There are 3 ways to form “rabbit” from “rabbbit”. Input: s = "babgbag", t = "bag" Output: 5 There are 5 ways to form “bag” from “babgbag”. 🔎 Approach Used: ➡️ Dynamic Programming (DP) — Space Optimized 1. Create two arrays (prev and curr) to store the count of subsequences. 2. Initialize base cases — there’s always one way to form an empty string. 3. For each character in s, compare it with each character in t: If characters match → add ways from both including and excluding it. If not → carry over the previous count. 4. Continue iterating and swap arrays to save space. ✅ Complexity Analysis: Time Complexity: O(n × m) Space Complexity: O(m) → Optimized 1D DP #50DaysChallenge #LeetCode #C++ #DynamicProgramming #Strings #Subsequences #DSA #CodingChallenge #Algorithms

🚀 Day 143 of #150DaysOfCode on LeetCode Problem: 2257. Count Unguarded Cells in the Grid Today’s challenge was a fun simulation and grid traversal problem! 🧩 In this task, we’re given a grid with guards and walls, and we must determine how many cells remain unguarded. Each guard can monitor cells in four directions — up, down, left, and right — until they’re blocked by a wall or another guard. This problem beautifully blends matrix manipulation, directional traversal, and boundary checks — concepts that often appear in real-world simulation tasks and game logic design. 🔍 Key Takeaways: Efficient grid representation simplifies complex visual problems. Direction-based iteration is a powerful technique for 2D traversal. Managing boundary conditions is essential in simulation-based coding problems. 🧠 Concepts Practiced: Grid traversal | Simulation | Matrix manipulation | Directional logic #LeetCode #150DaysOfCode #Day143 #CodingChallenge #LearnByDoing #ProblemSolving #Java #DSA #GridTraversal #Simulation #CodeEveryday

On Day 295 of my #300daysofcode challenge, I'm sharing my solution to LeetCode Problem 981, "Time Based Key-Value Store." This problem requires designing a specialized data store for version control. My video provides a clear walkthrough of the optimal design: using a HashMap to quickly find the key and then applying Binary Search on the timestamps to retrieve the correct historical value. This is a valuable skill for advanced data structure implementation and system design interviews. #DataStructures #Algorithms #LeetCode #CodingInterview #Programming #SystemDesign #300daysofcode

💯 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

💻 Day 50 of #LeetCode100DaysChallenge Solved LeetCode 6: Zigzag Conversion a problem that tests string manipulation and pattern simulation skills. 🧩 Problem: Given a string, write it in a zigzag pattern on a given number of rows, then read it row by row. The string must be transformed to match the zigzag layout. Example: For "PAYPALISHIRING" with numRows = 3, the zigzag pattern is: P A H N A P L S I I G Y I R Reading row by row: "PAHNAPLSIIGYIR" 💡 Approach — Row Simulation: 1️⃣ Handle edge case: if numRows == 1, return the original string. 2️⃣ Initialize numRows empty strings to represent each row. 3️⃣ Iterate through characters of the string: Use a variable currentRow to track which row to append to. Use a direction flag to move down or up the rows. 4️⃣ Append characters to their respective rows. 5️⃣ Join all rows to get the final zigzag string. ⚙️ Complexity: Time: O(N) — each character is processed once Space: O(N) — storage for all rows ✨ Key Takeaways: ✅ Practiced simulating non-linear string patterns. ✅ Strengthened control over iteration and direction changes. ✅ Reinforced thinking about mapping 1D data to 2D-like structures. #LeetCode #100DaysOfCode #Java #StringManipulation #PatternSimulation #DSA #CodingJourney #WomenInTech #ZigzagConversion

📌 Day 154 of Coding - Check If Digits Are Equal in String After Operations I (LeetCode - Medium) 🎯 Goal: Given a numeric string s, repeatedly replace it with a new string formed by taking the sum (mod 10) of every pair of adjacent digits, until only two characters remain. Return whether the final two digits are equal. 💡Approach & Debugging: Used a simple iterative simulation approach. For each iteration, formed a new string res by summing adjacent digits modulo 10. Replaced s with res and continued until the string length dropped to 2. Finally, compared both digits for equality. ✔️ Time Complexity: O(N*N) - since the string shrinks gradually each iteration. ✔️ Space Complexity: O(N) - temporary strings. 🧠 Key Takeaways: Some problems test simulation and string manipulation more than algorithms. Always track how input size evolves after each iteration. #Day154 #LeetCode #StringManipulation #Java #ProblemSolving #DSA #CodingChallenge #Algorithms #100DaysOfCode #InterviewPrep #SoftwareEngineering #DataStructures #CodeNewbie #ProgrammersLife

📌 Day 159 of Coding - Make Array Elements Equal to Zero (LeetCode - Easy) 🎯 Goal: Given an integer array nums, find the number of valid starting positions and directions such that by repeatedly decrementing and reversing direction (based on the rules), all elements eventually become 0. 💡Approach & Debugging: First computed total sum using Arrays.stream(nums).sum(). Maintained two prefix sums : left and right. For each index i where nums[i] == 0: Incremented left and decremented right progressively. Checked whether the left and right sums balance according to the movement rules. Counted valid selections when the balance was perfect or off by just one. ✔️ Time Complexity: O(N) - single pass through the array. ✔️ Space Complexity: O(1) - constant extra space. #Day159 #LeetCode #Simulation #Arrays #PrefixSum #Java #ProblemSolving #DSA #CodingChallenge #100DaysOfCode #Algorithms #InterviewPrep #SoftwareEngineering #DataStructures #CodeNewbie #ProgrammersLife