Maximizing Score in Grid with Constraints

🚀 #LeetCode Day Problem Solving 🚀 Day-44 📌 Problem: You are given an m × n grid with values {0,1,2} and an integer k 🎯 Start from (0,0) → reach (m-1,n-1) ✔ Only move right or down 💰 Cell Contribution: ValueScoreCost0+001+112+21🎯 Goal: ✔ Maximize score ✔ Total cost ≤ k ❌ If not possible → return -1 🧠 Example: Input: grid = [[0,1],[2,0]], k = 1 ✅ Output: 2 💡 Key Insight: ✔ This is DP + Constraint (Knapsack-style) problem 👉 At each cell: We track best score for each possible cost ⚡ State Definition: 👉 dp[i][j][c] = max score reaching (i,j) with cost c ⚡ Transition: From: Top (i-1, j) Left (i, j-1) Add current cell’s: ✔ score ✔ cost 🔥 Optimization Idea: ✔ Instead of full 3D DP → use rolling / pruning ✔ Keep only valid states where cost ≤ k ⚡ Final Steps: 1️⃣ Initialize DP 2️⃣ Traverse grid 3️⃣ Update states from top & left 4️⃣ Track maximum score at (m-1,n-1) with cost ≤ k 📊 Complexity Analysis: ⏱ Time Complexity: O(m * n * k) 📦 Space Complexity: O(m * n * k) (can optimize) 🧠 What I Learned: ✔ Grid DP with constraints ✔ Combining path + cost optimization ✔ Similar to Knapsack + Matrix traversal ✅ Day 44 Completed 🚀 Improving in DP + Optimization + Grid Problems 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

🚀 LeetCode Day Problem Solving 🚀 Day-60 📌 Problem: Given a 2D grid of characters, check if there exists a cycle of same characters 🔁 ✔ Move only in 4 directions (up, down, left, right) ✔ Cycle length must be ≥ 4 ✔ Cannot go back to the immediate previous cell 🧠 Example: Input: grid = [ ["a","a","a","a"], ["a","b","b","a"], ["a","b","b","a"], ["a","a","a","a"] ] ✅ Output: true 📖 Explanation: ✔ There exists a loop of 'a' forming a valid cycle 💡 Key Insight: ✔ This is a Graph Cycle Detection problem in a Grid 👉 Treat each cell as a node 👉 Connect adjacent cells with same value ⚡ Approach (DFS / BFS): 1️⃣ Traverse every cell 2️⃣ If not visited → start DFS 3️⃣ While exploring neighbors: Move only to same character Track previous cell (parent) 4️⃣ If you reach a visited cell (not parent) → 🔥 Cycle detected 🚫 Important Condition: ✔ Ignore the immediate parent to avoid false cycle 📊 Complexity Analysis: ⏱ Time Complexity: O(m × n) 📦 Space Complexity: O(m × n) (visited + recursion stack) 🧠 What I Learned: ✔ Grid problems = Graph problems 🧠 ✔ Cycle detection using DFS + parent tracking ✔ Careful handling of revisits ✅ Day 60 Completed 🚀 Leveling up in Graphs + DFS on Grid 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency #MilanSahoo 🚀

🚀 LeetCode Day Problem Solving 🚀 Day-42 📌 Problem: Range Update with Step & XOR You are given an array nums[] and multiple queries. Each query contains: [l, r, k, v] 👉 For every query: • Start from index l • Jump with step k → l, l+k, l+2k ... ≤ r • Update each visited index: nums[i] = (nums[i] * v) % (10⁹ + 7) After processing all queries, return: 👉 XOR of all elements in the array 🛠 Approach: ✔ Direct Simulation 👉 For each query: for i from l to r step k: nums[i] = (nums[i] * v) % MOD ✔ After all updates: 👉 Compute XOR of entire array 🧠 Key Learning: ✔ Handling range with step (k jump) ✔ Modular multiplication (10^9 + 7) ✔ Combining simulation + bitwise XOR 📊 Complexity: ⏱ Time: O(q * (n/k)) → worst case O(n * q) 📦 Space: O(1) 🧪 Example: Input: nums = [2,3,1,5,4] queries = [[1,4,2,3],[0,2,1,2]] After operations → [4,18,2,15,4] Output: 4 ^ 18 ^ 2 ^ 15 ^ 4 = 31 ✅ Day 42 Completed 🚀 Practicing Simulation + Bit Manipulation 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency #MilanSahoo 🚀

🚀 #LeetCode Day Problem Solving 🚀 Day-42 📌 Problem: You are given a grid and an integer x. 🎯 In one operation, you can: ✔ Add x OR subtract x from any element Goal 👉 Make all elements equal (uni-value grid) with minimum operations ❌ If not possible → return -1 🧠 Example: Input: grid = [[2,4],[6,8]], x = 2 ✅ Output: 4 📖 Explanation: ✔ Convert all elements → 4 using minimum steps 💡 Key Insight: ✔ All numbers must have the same remainder modulo x 👉 If (grid[i][j] % x) differs → ❌ impossible ⚡ Optimal Strategy: ✔ Convert 2D grid → 1D array ✔ Sort the array 👉 Best target value = median 🔥 Why median? ✔ Minimizes total number of operations (like minimizing absolute differences) ⚡ Steps: 1️⃣ Flatten grid → array 2️⃣ Check feasibility: All elements must satisfy same (value % x) 3️⃣ Sort array 4️⃣ Pick median element 5️⃣ Compute operations: 👉 ops += |value - median| / x 📊 Complexity Analysis: ⏱ Time Complexity: O(n log n) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ Median minimizes total distance ✔ Modular constraint check is critical ✔ Grid → array transformation simplifies problem ✅ Day 42 Completed 🚀 Improving in Greedy + Math Optimization 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

🚀 #LeetCode Day Problem Solving 🚀 Day-23 📌 Problem: Range Update with Step & XOR You are given an array nums[] and multiple queries. Each query contains: [l, r, k, v] 👉 For every query: • Start from index l • Jump with step k → l, l+k, l+2k ... ≤ r • Update each visited index: nums[i] = (nums[i] * v) % (10⁹ + 7) After processing all queries, return: 👉 XOR of all elements in the array 🛠 Approach: ✔ Direct Simulation 👉 For each query: for i from l to r step k: nums[i] = (nums[i] * v) % MOD ✔ After all updates: 👉 Compute XOR of entire array 🧠 Key Learning: ✔ Handling range with step (k jump) ✔ Modular multiplication (10^9 + 7) ✔ Combining simulation + bitwise XOR 📊 Complexity: ⏱ Time: O(q * (n/k)) → worst case O(n * q) 📦 Space: O(1) 🧪 Example: Input: nums = [2,3,1,5,4] queries = [[1,4,2,3],[0,2,1,2]] After operations → [4,18,2,15,4] Output: 4 ^ 18 ^ 2 ^ 15 ^ 4 = 31 ✅ Day 23 Completed 🚀 Practicing Simulation + Bit Manipulation 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

🚀 #LeetCode Day Problem Solving 🚀 Day-40 📌 Problem: Given a 2D grid of characters, check if there exists a cycle of same characters 🔁 ✔ Move only in 4 directions (up, down, left, right) ✔ Cycle length must be ≥ 4 ✔ Cannot go back to the immediate previous cell 🧠 Example: Input: grid = [ ["a","a","a","a"], ["a","b","b","a"], ["a","b","b","a"], ["a","a","a","a"] ] ✅ Output: true 📖 Explanation: ✔ There exists a loop of 'a' forming a valid cycle 💡 Key Insight: ✔ This is a Graph Cycle Detection problem in a Grid 👉 Treat each cell as a node 👉 Connect adjacent cells with same value ⚡ Approach (DFS / BFS): 1️⃣ Traverse every cell 2️⃣ If not visited → start DFS 3️⃣ While exploring neighbors: Move only to same character Track previous cell (parent) 4️⃣ If you reach a visited cell (not parent) → 🔥 Cycle detected 🚫 Important Condition: ✔ Ignore the immediate parent to avoid false cycle 📊 Complexity Analysis: ⏱ Time Complexity: O(m × n) 📦 Space Complexity: O(m × n) (visited + recursion stack) 🧠 What I Learned: ✔ Grid problems = Graph problems 🧠 ✔ Cycle detection using DFS + parent tracking ✔ Careful handling of revisits ✅ Day 40 Completed 🚀 Leveling up in Graphs + DFS on Grid 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

🚀 #LeetCode Day Problem Solving 🚀 Day-24 📌 Problem: Range Update with Step & XOR You are given an array nums[] and multiple queries. Each query contains: [l, r, k, v] 👉 For every query: • Start from index l • Jump with step k → l, l+k, l+2k ... ≤ r • Update each visited index: nums[i] = (nums[i] * v) % (10⁹ + 7) After processing all queries, return: 👉 XOR of all elements in the array 🛠 Approach: ✔ Direct Simulation 👉 For each query: for i from l to r step k: nums[i] = (nums[i] * v) % MOD ✔ After all updates: 👉 Compute XOR of entire array 🧠 Key Learning: ✔ Handling range with step (k jump) ✔ Modular multiplication (10^9 + 7) ✔ Combining simulation + bitwise XOR 📊 Complexity: ⏱ Time: O(q * (n/k)) → worst case O(n * q) 📦 Space: O(1) 🧪 Example: Input: nums = [2,3,1,5,4] queries = [[1,4,2,3],[0,2,1,2]] After operations → [4,18,2,15,4] Output: 4 ^ 18 ^ 2 ^ 15 ^ 4 = 31 ✅ Day 24 Completed 🚀 Practicing Simulation + Bit Manipulation 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency

Day 13 Part 2: When Code Doesn't Cooperate Morning: Voting ensemble working, R² = 0.822 Afternoon: Building stacking, hit errors Honest update: Still debugging. Most #BuildInPublic posts show wins. This is the between part. What I'm building: Stacking ensemble with meta-learner on top of base models. Should push R² from 0.822 → 0.83+. The plan: • Generate out-of-fold predictions from base models • Train Ridge meta-learner on those predictions • Prevent overfitting with CV The error: Shape mismatch in cross_val_predict. Expected (n_samples, n_models), getting inconsistent shapes across folds. What I've tried: Force reshape: Wrong predictions Manual CV loop: Implementing now Model verification: All compatible Tests status: 94 passing / 112 written 18 failing (all CV-related) Coverage: 83% What's working: • StackingEnsemble class implemented • BlendingEnsemble architecture done • Base tests passing • Voting ensemble production-ready What's not: • Out-of-fold prediction generation • Integration tests • Performance target not hit Timeline: Expected today, realistic tonight. 4-6 hours more work. Why share this: Real engineering = dealing with errors. Bugs happen. Implementation harder than expected. Timelines slip. Voting ensemble shipped and works. Foundation solid. Learning better debugging. Next update will be: "Stacking complete, R² = 0.83" or "Shipped voting, deferring stacking" Both valid outcomes. What I'm learning: Should have tested incrementally. Built too much before testing. Manual CV loop better than cross_val_predict for debugging. Ensemble complexity grows fast. Voting worked first try. Stacking debugging for hours. Been scheduling these honest updates via Buffer for 15 weeks. Consistency matters even when progress is messy. Link in comments. 📖 Full debugging notes: https://buff.ly/i0Ya2Eg 💻 Code: https://buff.ly/w2GD4ks #BufferIQ #BuildInPublic #MachineLearning #Debugging #HonestUpdates #RealEngineering

🚀 LeetCode Day Problem Solving 🚀 Day-62 📌 Problem: You are given a grid and an integer x. 🎯 In one operation, you can: ✔ Add x OR subtract x from any element Goal 👉 Make all elements equal (uni-value grid) with minimum operations ❌ If not possible → return -1 🧠 Example: Input: grid = [[2,4],[6,8]], x = 2 ✅ Output: 4 📖 Explanation: ✔ Convert all elements → 4 using minimum steps 💡 Key Insight: ✔ All numbers must have the same remainder modulo x 👉 If (grid[i][j] % x) differs → ❌ impossible ⚡ Optimal Strategy: ✔ Convert 2D grid → 1D array ✔ Sort the array 👉 Best target value = median 🔥 Why median? ✔ Minimizes total number of operations (like minimizing absolute differences) ⚡ Steps: 1️⃣ Flatten grid → array 2️⃣ Check feasibility: All elements must satisfy same (value % x) 3️⃣ Sort array 4️⃣ Pick median element 5️⃣ Compute operations: 👉 ops += |value - median| / x 📊 Complexity Analysis: ⏱ Time Complexity: O(n log n) 📦 Space Complexity: O(n) 🧠 What I Learned: ✔ Median minimizes total distance ✔ Modular constraint check is critical ✔ Grid → array transformation simplifies problem ✅ Day 62 Completed 🚀 Improving in Greedy + Math Optimization 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency #MilanSahoo 🚀

Constraints don’t limit your solution. They define it. Day 36 — Daily Engineering Practice (after a short break) Today I revisited Top K Frequent Elements. But instead of jumping into coding, I focused only on Step 1: Understanding: • Input • Output • Constraints • Edge cases And that alone clarified the entire direction. --- Key Insight: There are two types of constraints: 1️⃣ Size Constraints (n) → Decide Time Complexity • n ≤ 10³ → O(n²) works • n ≤ 10⁵–10⁶ → O(n log n) or O(n) • n ≤ 10⁷–10⁸ → Only O(n) (≈ 10⁷–10⁸ operations/sec rule) --- 2️⃣ Value Constraints (range) → Decide Data Structure • Small range → Array / Frequency Array • Large range → HashMap Arrays are faster, but only practical when the range is limited. HashMaps are flexible and work in both cases. --- What changed for me: Instead of asking “How do I solve this?” I now ask: “What are the constraints telling me?” That one question removes guesswork and narrows the approach instantly. --- Back to structured problem solving. Do you use constraints as a guide, or just treat them as limits? #DSA #Algorithms #LeetCode #SoftwareEngineering #ProblemSolving #LearningInPublic