Maximální postupné zvyšování délky cesty v binárním stromu
Vzhledem k binárnímu stromu najděte délku nejdelší cesty, která se skládá z uzlů s po sobě jdoucími hodnotami v rostoucím pořadí. Každý uzel je považován za cestu délky 1.
Příklady:
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).
Každý uzel v binárním stromu se může buď stát součástí cesty, která začíná jedním z jeho nadřazených uzlu, nebo může z tohoto uzlu začínat nová cesta. Klíčem je rekurzivně najít délku cesty pro levý a pravý podstrom a pak vrátit maximum. Některé případy je třeba vzít v úvahu při procházení stromu, které jsou popsány níže.
- předchozí : ukládá hodnotu nadřazeného uzlu. Inicializujte prev s hodnotou o jednu menší než je hodnota kořenového uzlu, aby cesta začínající v kořenu mohla mít délku alespoň 1.
- pouze : Ukládá délku cesty, která končí u rodiče aktuálně navštíveného uzlu.
Případ 1 : Hodnota aktuálního uzlu je předchozí +1
V tomto případě zvyšte délku cesty o 1 a pak rekurzivně najděte délku cesty pro levý a pravý podstrom a vraťte maximum mezi dvěma délkami.
Případ 2 : Hodnota aktuálního uzlu NENÍ prev+1
Z tohoto uzlu může začít nová cesta, takže rekurzivně najděte délku cesty pro levý a pravý podstrom. Cesta, která končí u nadřazeného uzlu aktuálního uzlu, může být větší než cesta, která začíná od tohoto uzlu. Vezměte tedy maximum z cesty, která začíná od tohoto uzlu a končí v předchozím uzlu.
Níže je implementace výše uvedeného nápadu.
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 < script > // 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 ) + '
' ); // This code is contributed by rag2127 < /script>
Výstup
Maximum Consecutive Increasing Path Length is 3
Časová složitost: O(n^2) kde n je počet uzlů v daném binárním stromu.
Pomocný prostor: O(log(n))
