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 0;
        int max = 0;
        dfs(root, max);
        return max;
    }

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

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

        if (root->right && root->right->val == root->val)
            r = 1 + 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 = 0
        
    def lastOrder(self,root):
        if root == None:
            return 0
        left = self.lastOrder(root.left)
        right = self.lastOrder(root.right)
        leftpath,rightpath = 0,0
        if root.left != None:
            leftpath = left + 1 if root.val == root.left.val else 0
        if root.right != None:
            rightpath = right + 1 if root.val == root.right.val else 0
        self.path = max(self.path,leftpath+rightpath)
        return max(leftpath,rightpath)
    
    def longestUnivaluePath(self, root: TreeNode) -> int:
        self.lastOrder(root)
        return self.path