二叉树中的最大连续增加路径长度

给定一棵二叉树，求最长路径的长度，该路径由具有按递增顺序的连续值的节点组成。每个节点都被视为长度为 1 的路径。
例子：

10
      /    \     
     /      \
    11        9    
   / \        /\
  /   \      /  \
13    12    13   8
Maximum Consecutive Path Length is 3 (10, 11, 12)
Note: 10, 9 ,8 is NOT considered since
the nodes should be in increasing order.

        5
          /  \
         /    \
        8      11
        /        \
       /          \
       9      10   
      /              /
     /             /
    6           15
Maximum Consecutive Path Length is 2 (8, 9).

二叉树中的每个节点都可以成为从其父节点之一开始的路径的一部分，或者新路径可以从该节点本身开始。关键是递归找到左右子树的路径长度，然后返回最大值。在遍历下面讨论的树时需要考虑一些情况。
prev ：存储父节点的值。使用比根节点的值小一的值初始化 prev，以便从根节点开始的路径长度至少为 1。
len ：存储在当前访问节点的父节点处结束的路径长度。
案例1 ：当前节点的值为prev +1
在这种情况下，将路径长度增加 1，然后递归地找到左右子树的路径长度，然后返回两个长度之间的最大值。
案例2 ：当前节点的值不是prev+1
一条新的路径可以从这个节点开始，所以递归地找到左右子树的路径长度。在当前节点的父节点结束的路径可能大于从该节点开始的路径。因此取从该节点开始到前一个节点结束的路径的最大值。
下面是上述想法的实现。

C++

// C++ Program to find Maximum Consecutive
// Path Length in a Binary Tree
#include 
using namespace std;
 
// To represent a node of a Binary Tree
struct Node
{
    Node *left, *right;
    int val;
};
 
// Create a new Node and return its address
Node *newNode(int val)
{
    Node *temp = new Node();
    temp->val = val;
    temp->left = temp->right = NULL;
    return temp;
}
 
// Returns the maximum consecutive Path Length
int maxPathLenUtil(Node *root, int prev_val, int prev_len)
{
    if (!root)
        return prev_len;
 
    // Get the value of Current Node
    // The value of the current node will be
    // prev Node for its left and right children
    int cur_val = root->val;
 
    // If current node has to be a part of the
    // consecutive path then it should be 1 greater
    // than the value of the previous node
    if (cur_val == prev_val+1)
    {
 
        // a) Find the length of the Left Path
        // b) Find the length of the Right Path
        // Return the maximum of Left path and Right path
        return max(maxPathLenUtil(root->left, cur_val, prev_len+1),
                   maxPathLenUtil(root->right, cur_val, prev_len+1));
    }
 
    // Find length of the maximum path under subtree rooted with this
    // node (The path may or may not include this node)
    int newPathLen = max(maxPathLenUtil(root->left, cur_val, 1),
                         maxPathLenUtil(root->right, cur_val, 1));
 
    // Take the maximum previous path and path under subtree rooted
    // with this node.
    return  max(prev_len, newPathLen);
}
 
// A wrapper over maxPathLenUtil().
int maxConsecutivePathLength(Node *root)
{
    // Return 0 if root is NULL
    if (root == NULL)
        return 0;
 
    // Else compute Maximum Consecutive Increasing Path
    // Length using maxPathLenUtil.
    return maxPathLenUtil(root, root->val-1, 0);
}
 
//Driver program to test above function
int main()
{
    Node *root = newNode(10);
    root->left = newNode(11);
    root->right = newNode(9);
    root->left->left = newNode(13);
    root->left->right = newNode(12);
    root->right->left = newNode(13);
    root->right->right = newNode(8);
 
    cout << "Maximum Consecutive Increasing Path Length is "
         << maxConsecutivePathLength(root);
 
    return 0;
}

Java

// Java Program to find Maximum Consecutive
// Path Length in a Binary Tree
import java.util.*;
class GfG {
 
// To represent a node of a Binary Tree
static class Node
{
    Node left, right;
    int val;
}
 
// Create a new Node and return its address
static Node newNode(int val)
{
    Node temp = new Node();
    temp.val = val;
    temp.left = null;
    temp.right = null;
    return temp;
}
 
// Returns the maximum consecutive Path Length
static int maxPathLenUtil(Node root, int prev_val, int prev_len)
{
    if (root == null)
        return prev_len;
 
    // Get the value of Current Node
    // The value of the current node will be
    // prev Node for its left and right children
    int cur_val = root.val;
 
    // If current node has to be a part of the
    // consecutive path then it should be 1 greater
    // than the value of the previous node
    if (cur_val == prev_val+1)
    {
 
        // a) Find the length of the Left Path
        // b) Find the length of the Right Path
        // Return the maximum of Left path and Right path
        return Math.max(maxPathLenUtil(root.left, cur_val, prev_len+1),
                maxPathLenUtil(root.right, cur_val, prev_len+1));
    }
 
    // Find length of the maximum path under subtree rooted with this
    // node (The path may or may not include this node)
    int newPathLen = Math.max(maxPathLenUtil(root.left, cur_val, 1),
                        maxPathLenUtil(root.right, cur_val, 1));
 
    // Take the maximum previous path and path under subtree rooted
    // with this node.
    return Math.max(prev_len, newPathLen);
}
 
// A wrapper over maxPathLenUtil().
static int maxConsecutivePathLength(Node root)
{
    // Return 0 if root is NULL
    if (root == null)
        return 0;
 
    // Else compute Maximum Consecutive Increasing Path
    // Length using maxPathLenUtil.
    return maxPathLenUtil(root, root.val-1, 0);
}
 
//Driver program to test above function
public static void main(String[] args)
{
    Node root = newNode(10);
    root.left = newNode(11);
    root.right = newNode(9);
    root.left.left = newNode(13);
    root.left.right = newNode(12);
    root.right.left = newNode(13);
    root.right.right = newNode(8);
 
    System.out.println("Maximum Consecutive Increasing Path Length is "+maxConsecutivePathLength(root));
 
}
}

Python3

# Python program to find Maximum consecutive
# path length in binary tree
 
# A binary tree node
class Node:
     
    # Constructor to create a new node
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
 
# Returns the maximum consecutive path length
def maxPathLenUtil(root, prev_val, prev_len):
    if root is None:
        return prev_len
 
    # Get the value of current node
    # The value of the current node will be
    # prev node for its left and right children
    curr_val =  root.val
     
    # If current node has to be a part of the
    # consecutive path then it should be 1 greater
    # than the value of the previous node
    if curr_val == prev_val +1 :
         
        # a) Find the length of the left path
        # b) Find the length of the right path
        # Return the maximum of left path and right path
        return max(maxPathLenUtil(root.left, curr_val, prev_len+1),
                   maxPathLenUtil(root.right, curr_val, prev_len+1))
 
    # Find the length of the maximum path under subtree
    # rooted with this node
    newPathLen = max(maxPathLenUtil(root.left, curr_val, 1),
                    maxPathLenUtil(root.right, curr_val, 1))
 
    # Take the maximum previous path and path under subtree
    # rooted with this node
    return max(prev_len , newPathLen)
 
# A Wrapper over maxPathLenUtil()
def maxConsecutivePathLength(root):
     
    # Return 0 if root is None
    if root is None:
        return 0
     
    # Else compute maximum consecutive increasing path
    # length using maxPathLenUtil
    return maxPathLenUtil(root, root.val -1 , 0)
 
# Driver program to test above function
root = Node(10)
root.left = Node(11)
root.right = Node(9)
root.left.left = Node(13)
root.left.right = Node(12)
root.right.left = Node(13)
root.right.right = Node(8)
 
print ("Maximum Consecutive Increasing Path Length is",)
print (maxConsecutivePathLength(root))
 
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

C#

// C# Program to find Maximum Consecutive
// Path Length in a Binary Tree
using System;
 
class GfG
{
 
    // To represent a node of a Binary Tree
    class Node
    {
        public Node left, right;
        public int val;
    }
 
    // Create a new Node and return its address
    static Node newNode(int val)
    {
        Node temp = new Node();
        temp.val = val;
        temp.left = null;
        temp.right = null;
        return temp;
    }
 
    // Returns the maximum consecutive Path Length
    static int maxPathLenUtil(Node root,
                int prev_val, int prev_len)
    {
        if (root == null)
            return prev_len;
 
        // Get the value of Current Node
        // The value of the current node will be
        // prev Node for its left and right children
        int cur_val = root.val;
 
        // If current node has to be a part of the
        // consecutive path then it should be 1 greater
        // than the value of the previous node
        if (cur_val == prev_val+1)
        {
 
            // a) Find the length of the Left Path
            // b) Find the length of the Right Path
            // Return the maximum of Left path and Right path
            return Math.Max(maxPathLenUtil(root.left, cur_val, prev_len+1),
                    maxPathLenUtil(root.right, cur_val, prev_len+1));
        }
 
        // Find length of the maximum path under subtree rooted with this
        // node (The path may or may not include this node)
        int newPathLen = Math.Max(maxPathLenUtil(root.left, cur_val, 1),
                            maxPathLenUtil(root.right, cur_val, 1));
 
        // Take the maximum previous path and path under subtree rooted
        // with this node.
        return Math.Max(prev_len, newPathLen);
    }
 
    // A wrapper over maxPathLenUtil().
    static int maxConsecutivePathLength(Node root)
    {
        // Return 0 if root is NULL
        if (root == null)
            return 0;
 
        // Else compute Maximum Consecutive Increasing Path
        // Length using maxPathLenUtil.
        return maxPathLenUtil(root, root.val - 1, 0);
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        Node root = newNode(10);
        root.left = newNode(11);
        root.right = newNode(9);
        root.left.left = newNode(13);
        root.left.right = newNode(12);
        root.right.left = newNode(13);
        root.right.right = newNode(8);
 
        Console.WriteLine("Maximum Consecutive" +
                        " Increasing Path Length is "+
                            maxConsecutivePathLength(root));
    }
}
 
// This code has been contributed by 29AjayKumar

Javascript

// Javascript Program to find Maximum Consecutive
// Path Length in a Binary Tree
 
// To represent a node of a Binary Tree
class Node
{
    constructor(val)
    {
        this.val = val;
        this.left = this.right = null;
    }
}
 
// Returns the maximum consecutive Path Length
function maxPathLenUtil(root,prev_val,prev_len)
{
    if (root == null)
        return prev_len;
   
    // Get the value of Current Node
    // The value of the current node will be
    // prev Node for its left and right children
    let cur_val = root.val;
   
    // If current node has to be a part of the
    // consecutive path then it should be 1 greater
    // than the value of the previous node
    if (cur_val == prev_val+1)
    {
   
        // a) Find the length of the Left Path
        // b) Find the length of the Right Path
        // Return the maximum of Left path and Right path
        return Math.max(maxPathLenUtil(root.left, cur_val, prev_len+1),
                maxPathLenUtil(root.right, cur_val, prev_len+1));
    }
   
    // Find length of the maximum path under subtree rooted with this
    // node (The path may or may not include this node)
    let newPathLen = Math.max(maxPathLenUtil(root.left, cur_val, 1),
                        maxPathLenUtil(root.right, cur_val, 1));
   
    // Take the maximum previous path and path under subtree rooted
    // with this node.
    return Math.max(prev_len, newPathLen);
}
 
// A wrapper over maxPathLenUtil().
function maxConsecutivePathLength(root)
{
    // Return 0 if root is NULL
    if (root == null)
        return 0;
   
    // Else compute Maximum Consecutive Increasing Path
    // Length using maxPathLenUtil.
    return maxPathLenUtil(root, root.val-1, 0);
}
 
// Driver program to test above function
let root = new Node(10);
root.left = new Node(11);
root.right = new Node(9);
root.left.left = new Node(13);
root.left.right = new Node(12);
root.right.left = new Node(13);
root.right.right = new Node(8);
 
document.write("Maximum Consecutive Increasing Path Length is "+
maxConsecutivePathLength(root)+"<br>");
 
// This code is contributed by rag2127

输出：

Maximum Consecutive Increasing Path Length is 3