124. Binary Tree Maximum Path Sum; 543. Diameter of Binary Tree; 687. Longest Univalue Path;

124. Binary Tree Maximum Path Sum

问题：

求出给定二叉树中，最大路径和（节点权值相加）。（至少包含树中一个节点）

Example 1:
Input: [1,2,3]
       1
      / 
     2   3
Output: 6

Example 2:
Input: [-10,9,20,null,null,15,7]
   -10
   / 
  9  20
    /  
   15   7
Output: 42

　　

解法：Binary Tree（二叉树）

由于本问题要利用递归求解，

那么递归中，必定含有一个联系上下文的变量root，

我们定义递归函数为，包含root节点为止，的最大path。

那么该递归函数help有以下特性：

1. 包含当前root节点

2. 只包含左右子树之一 or 两者都不包含。（最大path：若两子树都包含，那么在上层调用中，解只有 root+两个子树，无法向上传递，做出选择）

而我们利用help递归，要得到的真正的解为：

• 假设使用help求得了，左子树，右子树的最大路径 
  • l = help(root->left)
  • r = help(root->right)
• 对树中每个节点：
• MAX{
  • 只选择root
  • 选择root+左子树
  • 选择root+右子树
  • 选择root+左子树+右子树
• }

即：

res = max(res, 

root + max(l, 0) + max(r, 0)

)

对于递归函数help：

• DEF：
  • 包含root的，最大单侧子树路径。
• STAT：
  • root
• OPT：得到递归解 l 和 r
  • return max(root+l, root+r)
• BASE：
  • if root==null, then return 0

代码参考：

/**
 * 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:
    // RECURSION:
    //DEF: fun help(root):
    //    get the max path of one side, through current root node:
    //     [As a child res] of the whole question.
    //    (we need transfer this res to the upper question)
    //    1. contains the current root node.
    //    2. only contains one side child of this root node, or neither to choose(only root).
    //   = root->val + MAX {
    //      left child,
    //      right child,
    //      0
    //     }
    //STAT: root
    //OPT: 
    //  return root+ l or r(max)
    //BASE:
    // if root==null then: return 0;
    //
    // REAL ANS:
    // for each node, we need calculate:
    //  ans = max(ans,
    //            root 
    //                + max{help(root->left), 0}
    //                + max{help(root->right), 0}
    //         )

    int help(TreeNode* root, int& res) {
        if(!root) return 0;
        int l = max(0, help(root->left, res));
        int r = max(0, help(root->right, res));
        res = max(res, root->val + l + r);// real answer: root+l and r
        return root->val + max(l, r);// recursion answer: root+l or r
    }
    int maxPathSum(TreeNode* root) {
        if(!root) return 0;
        int res = INT_MIN;
        help(root, res);
        return res;
    }
};

543. Diameter of Binary Tree

问题：

求出给定二叉树中，最大路径（节点个数最多）。（至少包含树中一个节点）

Example:
Given a binary tree
          1
         / 
        2   3
       /      
      4   5    
Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].

Note: The length of path between two nodes is represented by the number of edges between them.

　　

解法：Binary Tree（二叉树）

同上题：

利用辅助函数help，进行递归：

求出，包含当前节点root，到单个子树的最大距离。

即，递归函数的返回值：1+max(l, r)

本题所求真正解为：

res= max( res, r+l ）

代码参考：

/**
 * 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 help(TreeNode* root, int& res) {
        if(!root) return 0;
        int l = help(root->left, res);
        int r = help(root->right, res);
        res = max(res, l+r);
        return 1+max(l, r);
    }
    int diameterOfBinaryTree(TreeNode* root) {
        if(!root) return 0;
        int res = 0;
        help(root, res);
        return res;
    }
};

687. Longest Univalue Path

问题：

求出给定二叉树中，最大相同节点的路径。（至少包含树中一个节点）

Example 1:
Input:
              5
             / 
            4   5
           /    
          1   1   5
Output: 2

Example 2:
Input:

              1
             / 
            4   5
           /    
          4   4   5
Output: 2

Note: The given binary tree has not more than 10000 nodes. The height of the tree is not more than 1000.

　　

解法：Binary Tree（二叉树）

同上题：

利用辅助函数help，进行递归：

求出，包含当前节点root，到单个子树的相同节点的最大路径。

• if root->val == left->val：l++
  • else l=0
• if root->val == right->val: r++
  • else r=0

即，递归函数的返回值：max(l, r)

本题所求真正解为：

res= max( res, r+l ）

代码参考：

/**
 * 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 help(TreeNode* root, int& res) {
        if(!root) return 0;
        int l = help(root->left, res);
        int r = help(root->right, res);
        if(root->left && root->val == root->left->val) {
            l = l+1;
        } else {
            l = 0;
        }
        if(root->right && root->val == root->right->val) {
            r = r+1;
        } else {
            r = 0;
        }
        res = max(res, l+r);
        return max(l,r);
    }
    int longestUnivaluePath(TreeNode* root) {
        if(!root) return 0;
        int res = 0;
        help(root, res);
        return res;
    }
};