DEV Community: Aman Saxena

The Unique Insight Behind the Binary Tree Maximum Path Sum (LeetCode 124)

Aman Saxena — Fri, 12 Dec 2025 05:05:37 +0000

Some coding interview problems feel routine… and then there are the ones that make you pause, sketch ideas, rethink your assumptions, and finally smile when the solution clicks.

For me, Binary Tree Maximum Path Sum was exactly that kind of problem.

It’s elegant.
It’s tricky at first glance.
And it teaches a powerful pattern used in many advanced tree problems.

If you're preparing for interviews or simply enjoy algorithmic puzzles, this one is worth mastering — and here’s why.

Problem Link

LeetCode 124 — Binary Tree Maximum Path Sum

Why This Problem Stood Out to Me

Most tree problems ask you to compute something simple like height, depth, or sum. But this one forces you to think differently:

A valid path doesn’t have to start at the root

A path can end anywhere

A path can go left → root → right, but cannot split upward

Sometimes the best path doesn’t even include the root

This combination makes the problem feel like a puzzle with multiple layers.

The “Aha!” moment is when you realize:

Each node must return the best one-sided path upward… but we must also track the best two-sided path that might pass through it.

Once this idea settles in, the recursion becomes surprisingly clean.

Putting It All Together With Examples

Once you understand the idea of one-sided paths and two-sided paths, the problem becomes much more intuitive. Here are a few examples that illustrate exactly how the recursion behaves and why the algorithm works.

Example 1 — The Classic “V” Shape Path

      1
     / \
    2   3

At node 1:
Best path going upward:
max(2, 3) + 1 = 4

Best through this node:
2 + 1 + 3 = 6

Maximum Path Sum = 6

Example 2 — When Negatives Force Interesting Choices

       -10
       /  \
      9   20
         /  \
        15   7

15 → 20 → 7

At node 20:

one-sided upward path: 20 + max(15, 7) = 35
two-sided local path: 15 + 20 + 7 = 42 ← candidate answer

The global maximum becomes 42, even though the root is negative.

Example 3 — Best Path Doesn’t Always Linear

        5
       / \
     4    8
    /    / \
   11   13  4
  /  \       \
 7    2       1

7 → 11 → 4 → 5 → 8 → 13

Sum = 48

All Negative Values

Sum = -2

The Core Idea Behind the Solution

Once you look at enough examples, the entire problem boils down to just two questions at every node:

What is the best path I can send upward?

This must be one-sided (left → node or node → right).

one_sided = node.val + max(left_gain, right_gain)

But if a side is negative, we drop it:

left_gain = max(dfs(left), 0)
right_gain = max(dfs(right), 0)

What is the best path that passes through this node?

This is where both sides can be used:

two_sided = left_gain + node.val + right_gain

This value updates the global maximum — but we never return it upward.

That’s the whole trick.

Final Solution

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 * right(right) {}
 * };
 */
class Solution {
public:
    int helper(TreeNode* root, int& maxVal) {
        if (!root) {
            return 0;
        }
        int leftPath = helper(root->left, maxVal);
        int rightPath = helper(root->right, maxVal);

        int pathVal = root->val + max(0, leftPath) + max(0, rightPath);
        maxVal = max(pathVal, maxVal);

        return root->val + max(max(0, leftPath), max(0, rightPath));
    }
    int maxPathSum(TreeNode* root) {
        if (root == NULL) {
            return 0;
        }
        int maxVal = INT_MIN;
        helper(root, maxVal);
        return maxVal;
    }
};

The Sliding Window Problem That Taught Me How to Think

Aman Saxena — Fri, 05 Dec 2025 16:15:53 +0000

It’s been five years since I last touched competitive programming.
Five years since staying up late solving problems just because they were beautiful —
since feeling that unique mix of frustration and excitement only algorithms can give.

Life got busy. Work changed. I moved on.

But recently, I decided to return.
Not as a student grinding contests, but as a developer trying to reconnect with the simple joy of thinking deeply again.

And the very first problem that reminded me why I loved competitive programming was:

Minimum Window Substring

A simple-looking question that gave me more than a challenge— it gave me clarity, humility, and honestly… a spark I had missed.

Returning After Years: The Strange Mix of Rust and Curiosity

Coming back to CP after years felt weird.

My fingers knew how to type fast, but my brain didn’t fire the way it used to.

Problems I would have solved in minutes now took me an hour.

I found myself overthinking simple cases, hesitating with patterns I once memorized.

But in that discomfort, something awakened:

I wasn’t here to be fast anymore.
I was here to enjoy thinking again.

And that mindset made this problem—of all problems—hit differently.

How Minimum Window Substring Helped Me Think Better Again

At first glance, the problem seems mechanical:

“Given strings s and t, find the smallest substring of s containing all chars of t.”

But solving it required something I had lost over the years:

🧠 the ability to break a problem down slowly, clearly, and logically.

I tried brute force.
I tried hashing.
I tried clever tricks that were, honestly, not clever at all.

Nothing worked.

Until one moment, when a simple idea clicked:

This isn’t a substring problem.
It’s a debt repayment problem.

And suddenly the entire algorithm unfolded in front of me.

That feeling—the sudden clarity after hours of confusion— is exactly why returning to CP was worth it.

Understanding the Debt Analogy (The Key Insight)

For t = "ABC" we “owe”:

A:1 B:1 C:1

Now we slide a window across s from left to right.

Every time we encounter a needed character,
we pay off a part of our debt.

When the debt becomes:

A:0 B:0 C:0

We have a valid window.

But valid is not enough—we want the minimum window.
So we try shrinking from the left until the window breaks again.

That balance—expanding greedily, shrinking optimally—
is the core beauty of this problem.

A Simple Diagram That Helped Everything Click

What finally made this problem “click” for me was watching the sliding window evolve across the string — not just a single moment.
The window goes through a complete cycle:

Expand until valid -> Shrink to find local minimum -> Expand again -> Shrink again -> Repeat until the end

Take the smallest valid window ever seen

Here’s the full walkthrough for:

s = A D O B E C O D E B A N C
t = A B C

Step 1:
[A]                   Debt: A0 B1 C1

Step 2:
[A D O B]             Debt: A0 B0 C1

Step 3:
[A D O B E C]         Debt: A0 B0 C0   ✓ First valid window

We finally satisfied all characters in t.
Now time to shrink

Window: [A D O B E C]
         ^
remove A → Debt: A1 B0 C0  → invalid

ADOBEC   (length 6)

Store it and keep moving.

[D O B E C O]
[D O B E C O D]
[D O B E C O D E]
[D O B E C O D E B]

[D O B E C O D E B A]   Debt: A0 B0 C0 → valid again

#shrink
[D O B E C O D E B A]
 ^
remove D → still valid
[O B E C O D E B A]
 ^
remove O → still valid
[B E C O D E B A]
 ^
remove B → Debt: B1 → invalid
BECODEBA  (length 8)

#continue
[E C O D E B A N C]
[B A N C] → valid (Debt satisfied)
[B A N C]
^
remove B → Debt: B1 → invalid
BANC   (length 4)

This is the global minimum across the whole string.

When you watch the window "breathe"—expanding and shrinking—
you start to feel the algorithm working.
And that feeling is something CP had trained me to pay attention to years ago.

C++ Solution (Sliding Window + Frequency Count)

class Solution {
public:
    string minWindow(string s, string t) {
        int m = s.length(), n = t.length();
        if (m < n)
            return "";

        unordered_map<char, int> need;
        for (char c : t)
            need[c]++;
        int required = need.size(); // these are required
        // this to create window
        unordered_map<char, int> window;
        int formed = 0;

        int left = 0, right = 0;
        int minLen = INT_MAX, start = 0;
        while (right < m) {
            char c = s[right];
            window[c]++;

            // check count in need map
            if (need.count(c) && window[c] == need[c]) {
                formed++;
            }
            // once made a window we reduce it
            while (left <= right && formed == required) {
                if ((right - left + 1) < minLen) {
                    minLen = right - left + 1;
                    start = left;
                }
                char d = s[left];
                window[d]--;
                if (need.count(d) && window[d] < need[d])
                    formed--;

                left++;
            }
            right++;
        }
        return minLen == INT_MAX ? "" : s.substr(start, minLen);
    }
};

From Contributor to Connector: What Hacktoberfest 2025 Taught Me

Aman Saxena — Thu, 16 Oct 2025 08:12:11 +0000

For the last few years, Hacktoberfest has been my excuse to dive into code — fixing bugs, improving docs, and contributing to projects like Open Policy Agent, Ortelius, and Real Dev Squad.

But this year, I decided to take a step back.

No code, no pull requests — just conversations.

I spent Hacktoberfest 2025 talking to people about open source.

How they could start, where to look, and most importantly, why it matters.

And honestly, it changed how I look at contribution.

Open source isn’t only powered by code — it’s powered by people. The ones who write, test, review, design, or simply encourage someone else to try. Watching someone make their first contribution after a quick chat felt just as good as merging my own PR.

I realized that being part of open source isn’t just about what you build — it’s about who you bring along.

So if you’re joining next year, start wherever you can.

Write, review, share, guide, or even just ask questions.

Because open source grows when more people feel they belong — and sometimes, the best way to contribute is to help someone else begin.

This Hacktoberfest reminded me that contribution isn’t always code — sometimes, it’s connection.

A Real-Time, High-Performance Voting Platform

Aman Saxena — Sat, 02 Aug 2025 15:31:09 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

What I Built

I built a real-time voting system using Go (Gin) and Redis 8, designed to handle live user interactions during high-traffic events like sports matches, elections, or social debates.
Create & manage polls with multiple options and expiry time.
Key Features

JWT-based authentication for users with role-based access (admin vs. regular users).
Vote tracking per user to prevent multiple submissions.
Real-time vote count updates using Redis Pub/Sub.
Admin-only controls to close or delete polls.
Fetch all polls with vote stats via a dedicated API.
Designed to scale horizontally with Redis Sets, Hashes, and Streams (planned).
Integration with genAI for real-time questions for polls, according to the events.

Design

Repo

link :- https://github.com/saxenaaman628/redis-voting-system (in progress)

How I Used Redis 8

Redis Hashes for Poll Metadata & Vote Counts
Redis Sets for Preventing Duplicate Votes
Redis Pub/Sub for Real-time Vote Updates
TTL on Poll Hashes

Contributors

@paaart
@jigyasa_saxena_9cca661789