leetcode687

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int longestUnivaluePath(TreeNode* root) {
        if (!root) return ;
        int max = ;
        dfs(root, max);
        return max;
    }

    int dfs(TreeNode* root, int & max) {
        int l = , r = ;

        if (root->left && root->left->val == root->val)
            l =  + dfs(root->left, max);
        else if (root->left)
            dfs(root->left, max);

        if (root->right && root->right->val == root->val)
            r =  + dfs(root->right, max);
        else if (root->right)
            dfs(root->right, max);

        if (l+r > max)
            max = l+r;

        return (l > r) ? l : r;
    }
};

补充一个python的实现：

 class Solution:
     def __init__(self):
         self.path = 

     def lastOrder(self,root):
         if root == None:
             return
         left = self.lastOrder(root.left)
         right = self.lastOrder(root.right)
         leftpath,rightpath = ,
         if root.left != None:
             leftpath = left +  if root.val == root.left.val else
         if root.right != None:
             rightpath = right +  if root.val == root.right.val else
         self.path = max(self.path,leftpath+rightpath)
         return max(leftpath,rightpath)

     def longestUnivaluePath(self, root: TreeNode) -> int:
         self.lastOrder(root)
         return self.path