LEETCODE 124. Binary Tree Maximum Path Sum

题目大意

给出一棵二叉树，求出里面的每个节点加起来值最大的路径的和。

解题思路

解决这一题的思路主要是遍历每一个点i，计算以这个点为根节点，并经过这个点的路径和的最大值，记作pathSum(i)，这个值可以用以下公式计算

$$maxSum(leftChild) + maxSum(rightChild) + val$$
其中maxSum()表示计算从某个点开始，一直往下的最大路径和，val是当前点i的值。
这个是可以通过递归算出来的，但是这无疑会产生会多重复计算的工作。所以我是从最底层的节点开始，先计算这些点的父节点，也就是倒数第二层节点的pathSum。计算完倒数第二层的节点，就可以计算倒数第三层的……
在计算每个点的pathSum的过程中，我们把最大的记录下来，就是题目要的结果了。

代码

#define max(a, b) (a > b ? a : b)

class Solution {
public:
    int maxPathSum(TreeNode* root) {
        int result = INT_MIN;
        stack<TreeNode*> leafStack;
        queue<TreeNode*> nodeQueue;
        map<TreeNode*, TreeNode*> parents;
        map<TreeNode*, int> maxSum;

        if (root == NULL) return 0;
        parents.insert(pair<TreeNode*, TreeNode*>(root, NULL));
        result = root->val;
        nodeQueue.push(root);
        while (!nodeQueue.empty()) {
            TreeNode* parent = nodeQueue.front();
            nodeQueue.pop();
            if (isLeaf(parent)) {
                maxSum.insert(pair<TreeNode*, int>(parent, parent->val));
                leafStack.push(parent);
                result = max(result, parent->val);
            }
            if (parent->left != NULL) {
                parents.insert(pair<TreeNode*, TreeNode*>(parent->left, parent));
                nodeQueue.push(parent->left);
            }
            if (parent->right != NULL) {
                parents.insert(pair<TreeNode*, TreeNode*>(parent->right, parent));
                nodeQueue.push(parent->right);
            }
        }

        while (!leafStack.empty()) {
            nodeQueue.push(leafStack.top());
            leafStack.pop();
        }

        while (!nodeQueue.empty()) {
            TreeNode* node = nodeQueue.front();
            if (node == root) break;
            nodeQueue.pop();
            TreeNode* parent = parents[node];
            int leftMax = 0;
            int rightMax = 0;
            if (parent->left != NULL) {
                if (maxSum.find(parent->left) == maxSum.end()) continue;
                leftMax = max(maxSum[parent->left], 0);
            }
            if (parent->right != NULL) {
                if (maxSum.find(parent->right) == maxSum.end()) continue;
                rightMax = max(maxSum[parent->right], 0);
            }
            maxSum.insert(pair<TreeNode*, int>(parent, max(0, max(leftMax + parent->val, rightMax + parent->val))));
            if (leftMax + rightMax + parent->val > result) {
                result = leftMax + rightMax + parent->val;
            }
            nodeQueue.push(parent);
        }

        return result;
    }

    bool isLeaf(TreeNode* root) {
        return root->left == NULL && root->right == NULL;
    }
};