Maximize Robot Earnings with Dynamic Programming and State Management

🚀 Day 26 of 100 Days LeetCode Challenge Problem: Equal Sum Grid Partition II Today’s problem is an advanced version of Day 25 with an extra twist 🔥 👉 Now we can remove (discount) at most one cell to balance the partition. 💡 Key Insight: We need: A horizontal OR vertical cut Two non-empty parts Equal sum OR can be made equal by removing one cell 🔍 Core Approach: 1️⃣ Total Sum Check Let total = sum of all elements 2️⃣ Try All Possible Cuts 👉 For each horizontal & vertical cut: Compute: Left/Top sum Right/Bottom sum 3️⃣ Check Two Cases: ✅ Case 1: Equal directly If both sums equal → return true ✅ Case 2: Difference can be fixed Let diff = |sum1 - sum2| Check if there exists a cell with value = diff In the larger partition 👉 Removing that one cell balances both sides ⚠️ Important Constraint: After removing a cell → the section must still be connected So avoid removing a “critical” cell that breaks connectivity 🔥 What I Learned Today: Small constraint changes → big increase in complexity Problem-solving requires checking multiple scenarios Combining prefix sums + validation logic is powerful 📈 Challenge Progress: Day 26/100 ✅ Beyond basics now! LeetCode, Prefix Sum, Matrix, Partition Problem, Graph Connectivity, Optimization, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #PrefixSum #Matrix #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

Computation is easy—the real challenge is knowing what to compute. In competitive programming, problems like counting pairs whose sum is divisible by k look straightforward, a vast pattern of questions of CodeForces and LeetCode revolve around this—but under contest pressure, they expose gaps in thinking efficiency. Brute force works… until it doesn’t. The real shift happens when you stop iterating over pairs and start reasoning in modular space since it reduces space from large n to defined m. Want to know, how I got this idea, try solving this problem - https://lnkd.in/gUrbzTV6 What most people miss is this: • It’s not about “optimizing loops” • It’s about changing the representation of the problem This is where many plateau—solving problems, but not upgrading their thinking model. Interestingly, this maps directly to real systems: • Hashing, partitioning, load balancing → all rely on similar modular reasoning • Efficiency comes from pre-computation and smart grouping, not brute force If you’re stuck in CP, it’s rarely a coding issue—it’s a thinking abstraction gap. How often do you step back and rethink the structure of a problem instead of optimizing your current approach? Let us discuss this further in the comments. Follow Vishu Kalier for more such deep dives. #CompetitiveProgramming #DSA #ProblemSolving #Algorithms #Coding #SystemDesign #cfbr #learninginpublic #roadtograndmaster #eternal #zomato

Spent some time solving 3 really interesting LeetCode contest problems today, and each one reinforced a different core DSA pattern. What I enjoyed most was how these seemingly small problems were actually testing pattern recognition more than implementation. 1) Mirror Frequency Distance This problem was all about symmetry and frequency mapping. Approach That I Used: Count the frequency of each character in the string. Map each character to its mirror counterpart: a ↔ z, b ↔ y 0 ↔ 9, 1 ↔ 8 Iterate through only half the range to avoid double counting. Sum the absolute frequency differences for every mirror pair. 2) Integers With Multiple Sum of Two Cubes This one immediately reminded me of the Ramanujan number (1729) concept. Approach That I Used: Generate all valid cube pairs (a, b) where: a³ + b³ ≤ n Store the frequency of each generated sum in a hashmap. Any number appearing 2+ times has multiple distinct cube representations. Return all such integers in sorted order. 3) Minimum Increments to Maximize Special Indices The most interesting one of the three because it involved DP state compression. & it took me an hour to do this question Approach: Treat every valid index as a candidate peak. Compute the cost required to make it greater than both neighbors. Maintain two rolling states: choose current index as peak skip current index Optimize first for: maximum number of peaks minimum cost among those choices Biggest learning from today: Contest questions often look implementation-heavy, but the real skill lies in identifying the hidden reusable pattern: frequency symmetry pair generation DP The more patterns we recognize, the faster we grow as problem solvers. Consistency is the real game changer. #LeetCode #DSA #DynamicProgramming #CompetitiveProgramming #ProblemSolving #C++ #CodingJourney #SoftwareEngineering

Day 88 on LeetCode Add Two Numbers 🔗➕💡 A classic linked list problem focusing on digit-wise addition with carry handling. 🔹 Approach Used in My Solution • Traverse both linked lists simultaneously • Maintain a carry variable for overflow • Add corresponding node values + carry • Create new nodes for result using a dummy head • Continue until both lists and carry are fully processed ⚡ Complexity: • Time Complexity: O(max(n, m)) • Space Complexity: O(max(n, m)) 💡 Key Takeaways: • Dummy node simplifies linked list construction • Carry handling is the core concept in this problem • Reinforces simulation of real-world arithmetic using linked lists 🔥 Another step forward in strengthening pointer-based problem solving. #LeetCode #DSA #Algorithms #DataStructures #LinkedList #AddTwoNumbers #CarryLogic #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #Consistency #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Keeping it Simple: Solving the "Mirror Distance" Problem! 🧩 I recently tackled an interesting problem on LeetCode: Mirror Distance of an Integer. 🔍 The Challenge: Find the "Mirror Distance," which is the absolute difference between an integer n and its reverse. 🧪 Example: Input: n = 25 Reverse: 52 Calculation: |25 - 52| = 27 ⚙️ My Approach: 1️⃣ Reverse the digits: Used a simple while loop to extract digits and rebuild the number in reverse. 2️⃣ Handle Constraints: Used long long to prevent potential overflow since n can go up to 10⁹. 3️⃣ Absolute Difference: Calculated the final result using the abs() logic. 💡 Insight: Sometimes, the most satisfying part of coding is finding a clean and efficient solution to a straightforward problem. 💻 Keep coding! 🚀 #LeetCode #CodingChallenge #DataStructures #Algorithms #ProblemSolving #Cpp #SoftwareEngineering #DailyCoding

🚀 Day 42 of #GeekStreak60 ✅ Problem Solved: Consecutive 1's Not Allowed Today’s problem looked simple at first, but it turned into a really clean Dynamic Programming pattern. The task was to count all binary strings of length "n" such that no two 1’s are consecutive. Instead of generating all possibilities (which would be exponential), I learned how to break it down using a recurrence relation. The key observation was that a valid string ending with "0" can come from any valid string of length "n-1", while a string ending with "1" must come from a string of length "n-2". This leads to a Fibonacci-like relation, making the solution efficient and elegant. 💡 Key Takeaways: • Recognizing patterns (like Fibonacci) simplifies complex problems • DP is powerful when overlapping subproblems exist • Thinking in terms of “choices at each step” is a game changer 📈 Consistency > Motivation 🔥 Current Streak: 42 days Let’s keep building, one problem at a time. #DSA #DynamicProgramming #CodingJourney #ProblemSolving #GeeksforGeeks #100DaysOfCode #Consistency #Learning #Growth

Solved "Maximum Subarray" on LeetCode ✅ • All test cases passed • Runtime: 0 ms ⚡ Approach 🧠:- • Implemented "Kadane’s Algorithm". • Used a running sum to track the current subarray • At each step, compared current sum with maximum sum so far • If the running sum becomes negative, reset it to 0 (since it won’t help in future subarrays) About the Code 💻:- • Initialized `maxsum` with `INT_MIN` to handle negative arrays • Iterated through the array once using a loop • Updated `sum` by adding current element • Used `max()` to continuously track the best answer • Reset condition ensures we always start fresh when needed Complexity 📊:- • Time Complexity: O(n) • Space Complexity: O(1) Takeaway 🎯:- • This is a classic example of optimizing from brute force to linear time • Helps in understanding greedy + dynamic programming patterns --- #LeetCode #Algorithms #Coding #ProblemSolving

🚀 Day 69 of #100DaysOfCode 🔥 Problem: Majority Element II (LeetCode 229) Today’s challenge was all about finding elements that appear more than ⌊n/3⌋ times in an array. Sounds simple, but the twist is doing it efficiently! 💡 Key Insight: Instead of counting frequencies using extra space, we can use an optimized approach based on the Boyer-Moore Voting Algorithm. ✨ Approach Highlights: • There can be at most 2 majority elements (> n/3) • Maintain 2 candidates and their counts • First pass → find potential candidates • Second pass → verify their frequency ⚡ Why this works? Because any element appearing more than n/3 times will survive the elimination process. 📈 Complexity: • Time: O(n) • Space: O(1) 🎯 Takeaway: Smart algorithms > brute force. Understanding patterns like voting algorithms can save both time and space! #DSA #LeetCode #CodingJourney #ProblemSolving #100DaysOfCode #Algorithms #Programming

Solved the Unique Paths problem using Dynamic Programming. The problem is to find the number of ways to reach the bottom-right corner of a grid, starting from the top-left, moving only right or down. I initially found the recursive approach quite easy to understand: • From any cell, you can either move right or move down • So total paths = right paths + down paths But when it came to converting this idea into tabulation (bottom-up DP), it felt a bit challenging. Understanding how to fill the DP table in the correct order and handling boundaries took some effort. Approach: • Start from the destination cell and assign it value 1 • Move backwards and calculate each cell as: paths from right + paths from down • Build the solution iteratively using a 2D DP table Time Complexity: O(M × N) Space Complexity: O(M × N) What I realized is that: thinking in recursion feels natural, but converting that thinking into tabulation requires practice and a clear understanding of state transitions. Still learning and improving with each problem. #DSA #DynamicProgramming #Algorithms #CodingJourney #ProblemSolving

Solved “Letter Combinations of a Phone Number” on LeetCode 💡 What looks simple on the surface is actually a clean exercise in recursion + backtracking. 🔍 Key takeaways: - Mapping digits to characters is straightforward, but generating all combinations efficiently is where the thinking comes in - Backtracking helps explore all possibilities while keeping the solution clean and scalable - Important to control recursion depth and maintain state (temp) correctly 💭 What I focused on: - Building combinations incrementally - Reverting state after each recursive call (classic backtracking pattern) - Keeping the solution readable and modular This problem reinforced how powerful recursion is when combined with proper state management. On to the next one 🚀 #DSA #LeetCode #Backtracking #Recursion #ProblemSolving #CodingJourney