Največja zaporedno naraščajoča dolžina poti v binarnem drevesu
Za podano binarno drevo poiščite dolžino najdaljše poti, ki je sestavljena iz vozlišč z zaporednimi vrednostmi v naraščajočem vrstnem redu. Vsako vozlišče se obravnava kot pot dolžine 1.
Primeri:
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).
Vsako vozlišče v binarnem drevesu lahko bodisi postane del poti, ki se začne od enega od svojih nadrejenih vozlišč, bodisi se lahko nova pot začne od tega vozlišča samega. Ključno je rekurzivno najti dolžino poti za levo in desno poddrevo in nato vrniti največjo vrednost. Med prečkanjem drevesa je treba upoštevati nekatere primere, ki so obravnavani spodaj.
- prev : shrani vrednost nadrejenega vozlišča. Inicializirajte prev z eno manj kot vrednostjo korenskega vozlišča, tako da je lahko pot, ki se začne pri korenu, dolga vsaj 1.
- samo : Shrani dolžino poti, ki se konča pri nadrejenem trenutno obiskanem vozlišču.
Primer 1 : Vrednost trenutnega vozlišča je prev +1
V tem primeru povečajte dolžino poti za 1 in nato rekurzivno poiščite dolžino poti za levo in desno poddrevo, nato vrnite največjo vrednost med dvema dolžinama.
Primer 2 : Vrednost trenutnega vozlišča NI prev+1
Nova pot se lahko začne iz tega vozlišča, zato rekurzivno poiščite dolžino poti za levo in desno poddrevo. Pot, ki se konča pri nadrejenem vozlišču trenutnega vozlišča, je lahko večja od poti, ki se začne od tega vozlišča. Zato vzemite največjo pot, ki se začne od tega vozlišča in konča pri prejšnjem vozlišču.
Spodaj je izvedba zgornje ideje.
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>
Izhod
Maximum Consecutive Increasing Path Length is 3
Časovna kompleksnost: O(n^2), kjer je n število vozlišč v danem binarnem drevesu.
Pomožni prostor: O(log(n))
