Diameter of a Binary Tree - Leetcode 543 - Python
Vložit
- čas přidán 25. 07. 2024
- 🚀 neetcode.io/ - A better way to prepare for Coding Interviews
🐦 Twitter: / neetcode1
🥷 Discord: / discord
🐮 Support the channel: / neetcode
Coding Solutions: • Coding Interview Solut...
Problem Link: neetcode.io/problems/binary-t...
0:00 - Read the problem
1:35 - Drawing Explanation
12:45 - Coding Solution
leetcode 543
This question was identified as a Google interview question from here: github.com/xizhengszhang/Leet...
#tree #diameter #python - Věda a technologie
🚀 neetcode.io/ - I created a FREE site to make interview prep a lot easier, hope it helps! ❤
Alternative mathematical approach: It made a little more sense to me to return 0 for a Null node. In doing so, you don't need the + 2 in the updating of the result. You are essentially accounting for the parent edge in different ways. I found this approach to come a little more naturally to me, so I'm posting in case it helps anyone!
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
def dfs(root):
nonlocal diameter
if root is None:
return 0
left = dfs(root.left)
right = dfs(root.right)
diameter = max(left + right, diameter)
return max(left, right) + 1
diameter = 0
dfs(root)
return diameter
cannot agree more!
Thanks for this solution!
Thank you, now I see no advantage of using -1
What does the left + right part do exactly, and why is it needed? Im able to follow everything else though, just confused about that and why we are calculating 2 maxes.
@@bashaarshah2974 That's the diameter in current subtree.
In what universe is this an "easy" problem?
I was thinking the same thing during the video. If this is an easy problem then I'm a Porsche Cayenne.
@@HeinekenLasse Yeah this one is definitely a medium
I spend 1 whole day trying to solve this one but in the end had to watch this video
This is actually very easy if you don't do the -1 +2 bullshit.
All you gotta do is height of left, height of right and return the bigger of the two + 1 (to add current node) in each recursive call.
The diameter at each node is then leftHeight + rightHeight
Got confused during this video and solved it on my own first try in 5 min
Oh thank God someone else thinks so
If you are new to Data Structures and don’t understand recursion concept in Trees, don’t worry. I used to be like that until I find this channel sometime ago. White boarding is a must practice to understand Trees. Watch as many videos as possible. Later you can worry about the code. It will be that one snap of a moment you need to wait for to realize that you understood Trees. I had that snap of a moment. Don’t give up. We are Engineers 👩💻 👨💻
thanks man
Then we never use trees again after gettinga. job. Until we get layed off and have to do leetcode again
@@sarbjotsingh9998 explained my suituation here :p
thx bro
thx brodie
I think this problem deserves an update. The way you explained it is pretty complicated. It's way more intuitive to simply count the number of edges.
```
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
if not root: return 0
diameter = 0
def dfs(node):
if not node: return 0
edges_l = dfs(node.left) if node.left else 0
edges_r = dfs(node.right) if node.right else 0
nonlocal diameter
diameter = max(diameter, edges_l + edges_r)
edges = 1 + max(edges_l, edges_r)
return edges
dfs(root)
return diameter
```
What's edges for though?
This looks amazing ! I came up with similar solution as Neetcode, but this looks more neat, Good Job!
I will credit you when I add this on leetcode.
Thanks.
My first solution was very close to this. Thanks!!
This one is quite difficult, do you think it should be labeled as medium?
should be mdeium, even be hard I think
@@maxchen7529can’t be hard，but I think it should be hard-medium
The arithmetic is unnecessary: if we return 0 in basecase and set diameter = left+right, the solution is still the same.
agreed. it's using depth vs using height which is the num of edges from root to bottommost node
I found this explanation quite difficult to follow, especially around 8:19, when NeetCode starts talking about "convention" to make the math work. The solution works, yes, but I am left a little dissatisfied with the overall explanation as it is still quite unclear. I don't seem to find this convention being used in other problems, but maybe that's because I haven't done enough of them yet.
think by yourself, nobody will think for you
@@user-ib3ev5pl2t Nobody is expecting the other to think for them, but if something is meant to make things easier, it should make things easier, otherwise what's the point? Clearly this explanation was off and made things difficult.
Agree with you. The maths should fit the problem, not the problem fit the maths
I felt I could easily get so confused by this tricky -1 counting algo... later I found out another alternative which seems more clear to me is to just use max() to include both cases instead:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
ans = 0
def longestPath(node):
if not node: return 0
left = longestPath(node.left)
right = longestPath(node.right)
nonlocal ans
ans = max(ans, left + right)
return max(left, right) + 1
longestPath(root)
return ans
Thank you for sharing this. I understood this method more clearly.
thank you. The tricky part of this problem is the -1, +1, height, diameter. So many tutorials just take them for granted and offer no explanation, but you did an amazing job talking about the whys. Bags of thanks!
Yeah this was a breakthrough for me as nobody in leetcood discussions were talking about this and I was so confused.
how this can be an easy problem
First of all, thanks for this fantastic channel! However, for this problem I find the following code way easier:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
def traversal(root):
nonlocal max_d
if not root:
return 0
left_d = traversal(root.left)
right_d = traversal(root.right)
max_d = max(left_d + right_d, max_d)
return max(left_d, right_d) + 1
max_d = 0
traversal(root)
return max_d
This solution was easier for me to understand, thanks. What's the intuition around calculating max_d though? How do you know to use the sum of heights?
@@EE12345 the max diameter of a node is equal to the (max height of left + 1) plus (max height of right +1) - the longest path going through it.
however in this solution the +1 is already being incorporated in the return, so defining the height as "the number of edges being given to the parent node". which means that in this solution, height is 0 for null nodes and 1 for childless ones
This explanation and code is wayyyy better than the one on GFG... Thanks a lot!! ❤
best explaination on recursive functions and binary tree diametre problem , thanks for the video , this video will blow up , ill share this masterpiece with my friends too :)))
Great video! One question, why you use list type global res? why cannot you just use res=0 ? Thank you!
Python makes a copy of the primitive types if you pass them in the function so the value doesn't change outside of the function. He used a non-primitive type (list object) to make changes because a list object is stored on the heap and is pass-by-reference. He could've also made a class variable called self.res= 0 and used it in the function with self.res
@@ruspatel1996 Thank you so much for the clear explain! Really appreciate it!
@@ruspatel1996 Came here looking for just this question. Sort of a python 'gotcha' then.
@@ruspatel1996 isn't it more like this?
if we just use res we are assigning a local variable "res" inside a dfs function so when python interpreter meets "max(res,2+left+right" res doesn't have any value
but with res[0] it is not assigning it is actually reading value. so python interpreter will see there is no local variable "res" inside dfs function and move on to outer scope
@@dohyun0047yeah, i thought so too, at least in this case, you actually wouldn't need a mutable variable, a simple res=0 would suffice.
Edit: sorry, my mistake, it's a python scope thing, you do need a list, got it.
I cracked at 'The leftsubtree is left right'
The core idea for this issue is pretty much the same as the Hard problem max path sum(lc 124),
for a node, we have two options,
1. split
2. no split
if we split at the current node, we'll have to calculate the path left -> current-> right.
In contrast, if we don't split we'll have to return the max path the current node could return to its parent.
Hope it helps
Very helpful!
Clear explanation with graphic. Thank you!
thanks for the effort into making the solution very carefully explained before jumping into the code
I didn't do it this way, my solution was based on your video on max path sum in binary tree. The principle still holds here.
Yeah this is true. It's way easier to remember also. Basically two problems for the price of remembering one!
var diameterOfBinaryTree = function(root) {
let max = 0
dfs(root)
return max
function dfs(root) {
if (root == null) {
return null
}
let left = dfs(root.left)
let right = dfs(root.right)
max = Math.max(max, left + right)
return 1 + Math.max(left, right)
}
};
Very clear explanation! Helped me get through the problem.
I made use of the maximumDepth problem to get the depths of the subtrees of a node, added them to get the diameter wrt a node. Then recursively called the diameter function on the left and right children and returned the max of the three. I felt this made sense to me from understanding standpoint. Putting my code for reference.
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
#find the depth of left and right subtree from each node. Sum them to get the diameter wrt that node.
#recursively call the same fn on the right and left child to get the same.
#return the maximum of the three i.e., current diameter, diameter of right child, diameter of left child.
def depth(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
right = 1 + self.depth(root.right)
left = 1 + self.depth(root.left)
return max(right,left)
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
if not root:
return 0
rightdepth = self.depth(root.right) if root.right else 0
leftdepth = self.depth(root.left) if root.left else 0
dia = rightdepth + leftdepth
return max(dia, self.diameterOfBinaryTree(root.right), self.diameterOfBinaryTree(root.left) )
Hope this helps!
For anyone reading this in future, this was my initial attempt too and did help me understand but it is actually O(N^2). Every call of depth will have O(N) complexity and diameterOfBinaryTree will also be called N times as we're calling it on every node.
the time complexity is the problem
Out of so many videos, this is the first time that I think my solution is more clear and self-explained. :).
// Notice that when the tree is like a triangle, its maxDiamter is just left tree height plus right tree height.
var diameterOfBinaryTree = function (root) {
/**
* Returns the height of a tree.
* A tree with a single node is of height 1.
*/
function getHeight(cur) {
if (!cur) return 0; // The end of tree, height is 0
const leftHeight = getHeight(cur.left);
const rightHeight = getHeight(cur.right);
const curDiameter = leftHeight + rightHeight;
maxDiameter = Math.max(maxDiameter, curDiameter);
return 1 + Math.max(leftHeight, rightHeight);
}
let maxDiameter = 0;
getHeight(root);
return maxDiameter;
};
why the global variable is set to res = [0] instead of res = 0?
that has to be a mistake. it does not have to be an array.
@@Incroachment
if you use res = 0 . changes inside the function won't affect the original variable outside the function,search for Immutable vs Mutable
res = [0] is no mistake, sure you can initialize it as res = 0 but then you have to use "nonlocal res" to make it accessible inside the helper dfs() function because integer objects are immutable objects ( if you try to modify it inside helper dfs() fucntion without using "nonlocal" the program will create a new object instead of using outer scope object). On the other hand list objects are mutable objects so can modify it anywhere in the program. #maile7853 #Incroachment
This is the best explanation that one could give on recursion. You are a great teacher 👍
Hi @NeetCode can you please explain why you take 'res' as a list not a variable.
that is becasue how python's scope works. you cannot modify the variable if it is in outer scope. u can still use a variable but u have to use "nonlocal" keyword before using res inside dfs to let python know that this is in outer scope
res=0
def dfs(root):
.......
.......
nonlocal res
res=max(res,2+left+right)
@@veliea5160 Thank you so much ...now it seems clear
@@veliea5160 thank you :)
thank you for asking this question
Also you usually use nonlocal if you want to make that variable global AND you want to modify it. If your not modifying and just looking then you can call it normally without nonlocal
Creating a list to store the update result is so inspiring.
Can you explain why you would use a list and not simply 0?
@@tonyiommisg List can update and store values by avoiding returning something in a helper function. In my habit, sometimes it is a little bit tricky for me to code with return in the helper function.
It's not just about avoiding your bad habit. It is in fact necessary to create a list here to store and update the final diameter value. The list in Python is mutable, meaning that you can update/mutate elements of a list whether the list is global or not. If you choose to use a global integer variable, then you always have to declare it is global inside your helper function to update it. Otherwise, you code will throw an error. Oh, and the global variables must be defined outside of the class. Code example below:
res = 0
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
def helper():
global res
if not root: return -1
left = helper(root.left)
right = helper(root.right)
res = max(res, 2+left+right)
...
You may argue what if we pass res as a helper function's argument like "def helper(res):" and then can we avoid declaring that it is global? The answer is no. When you pass the variable as a function's argument, then it will only create a copy of the global variable that is in a different memory location from the global variable. This will result in keeping the global variable "res" unchanged the whole time. If you want to dig deeper on this, refer to this documentation. www.dataquest.io/blog/tutorial-functions-modify-lists-dictionaries-python/.
We can also use "nonlocal" inside the dfs() like:
res = 0
def dfs(root):
nonlocal res
...
@@mdazharuddin4684 nonlocal is a better solution
To avoid the -1 or 0 definition, one can build a graph based on the tree. Finding a path based on a graph is pretty intuitive. The process of building a graph based on a tree is mechanical. So, it is easy after some practice.
very clear! THX!
I think this solution will be a bit simpler to understand
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
def dfs(root):
nonlocal res
if not root:
return 0
left = dfs(root.left)
right = dfs(root.right)
res = max(res, left + right + 1)
return 1 + max(left, right)
res = 0
dfs(root)
return res - 1
Why is res initialized to [0]. I get that res = 0 gives a run time error. But how is res = [0] different?
I guess because of scoping? Python creates a new variable in the local scope, so in order to use the global res you need the array to be a container? I guess... lol
What is the software he uses to draw? I definitely could help myself drawing some problems out
Excalidraw, or just paint lol
Is there a bug in this at: czcams.com/video/bkxqA8Rfv04/video.html ? You say D = L + R + 2, but you add it as D = 1 + -1 + 2 = 1, but shouldn't it be 2?
Great explanation!!
Why do you use [0] for res and not just simply 0?
you will get local variable referenced before assignment
unless you go self.res
idk why though anyone knows the reason?
@@richardyeh718 I guess because of scoping? Python creates a new variable in the local scope, so in order to use the global res you need the array to be a container? I guess... lol
What app are you using to draw on screen?
Hey i have a doubt regarding res variable I did very similar one with it, I used variable instead of array but I keepts throwing me local variable reference before assignment could you say what is wrong with it.
Use self.res instead of res for the variable.
I guess because of scoping? Python creates a new variable in the local scope, and will see the out of scope variable as immutable, so in order to use the global res you need the array to be a container? I guess... lol
Why we are not concern with Linked Node approch ... as compare to the array one? its easier that's we can say .. but is there any other reason why we don't land up for Linking Nodes and computing
Thanks for the vid but why are you initializing res to an array?
I guess because of scoping? Python creates a new variable in the local scope, and will see the out of scope variable as immutable, so in order to use the global res you need the array to be a container? I guess... lol
Great solution💯. Thanks for the explanation. Something I noted about the solution. You set the global variable 'res' to be an array of length 1 instead of using an integer. This has been a problem for me in other recursive questions. Could you explain why an array works as a global variable in recursive questions and not integers? Thank you!
In python land, non-primitive datatypes such as list are passed by value. This makes it possible to update it rather making copy everytime. Hope this helps :)
@@niteshrawat576 Thank you. That makes sense!
can anyone explain why res is array instead of int?
same question, did you find the answer?
This is used as a workaround in Python. In Python, inner functions have access to variables in the outer function but they cannot modify them without using a workaround. Due to a quirk of Python's name binding, we can use a mutable object such as a list to bypass this problem. However, it is an awkward workaround and not the 'Pythonic' way to modify outer function variables. The proper convention here is to use nonlocal as shown below:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
res = 0
def dfs(root):
nonlocal res
if not root:
return -1
left = dfs(root.left)
right = dfs(root.right)
res = max(res, 2 + left + right)
return 1 + max(left,right)
dfs(root)
return res
@@EverydayAwes0me ah yes, the "this technically isn't how the language is supposed to work but we're going to take advantage of its quirks" answer. Bad technique for the workforce.
Why is the height at root node of the left tree 2?
Same solution as others have pointed out, but with more understandable variable names so you can guess better what is going on:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
self.diameter = 0
def height(node) -> int:
if not node:
return 0
left_height = height(node.left)
right_height = height(node.right)
# Update the diameter if the current path is longer
self.diameter = max(self.diameter, left_height + right_height)
# Return the maximum height of the current node
return max(left_height, right_height) + 1
height(root)
return self.diameter
The ambiguity of the problem comes from combining the two concepts together. The HEIGHT of the tree AND the longest PATH.
Those are not the same. Consider the binary tree:
1
/
2
The height of the tree is 2, but the longest path is 1 (the number of edges).
Here is a more explicit solution to the problem in Javascript (it should be pretty similar to the Python code). The variable "d" is not used really, but added to debug the state at the given moment.
function diameterOfBinaryTree(root) {
let max = 0
function dfs(root) {
if (!root) {
return [0, 0, 0]
}
const [,heightLeft, nPathLeft] = dfs(root.left)
const [,heightRight, nPathRight] = dfs(root.right)
// number of edges
const n = (root.left ? 1 : 0) + (root.right ? 1 : 0)
const d = n + nPathLeft + nPathRight
const h = 1 + Math.max(heightLeft, heightRight)
// the longest path
const p = h - 1
max = Math.max(max, d)
return [d, h, p]
}
dfs(root)
return max
}
Can someone please explain how would we actually implement the brute force solution? Are we not gonna use recursion there? Will it be an iterative solution using stacks or queues?
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
res = [0]
def height(root):
if not root:
return 0
left = height(root.left)
right = height(root.right)
return 1+max(left, right)
def diameter(root):
if not root:
return 0
left_height = height(root.left)
right_height = height(root.right)
diameter(root.left)
diameter(root.right)
res[0] = max(res[0], left_height+right_height)
diameter(root)
return res[0]
From a node...we need to find left and right depths.....and adding it.
We do the same from very other node.
8:44 you said D= 1+(-1)+2 = 1, that's incorrect. I think you just didn't cut it out properly because you corrected it right after.
Thank you Deve, I was thinking a lot about this in minute 8:44 , because I didn't understand :), it should be 0 + (-1) + 2 = 1
@NeetCode do you really recommend educative I have already done around 100 lc problems, will it help me?
How does Diameter = L+ R+2? and why do you return -1 for a null node while in the "max depth of binary tree" problem we return 0?
The +2 accounts for 1 edge leading to each tree on the left and right.
Why are we using res[0] instead of res?
It is in fact necessary to create a list here to store and update the final diameter value. The list in Python is mutable, meaning that you can update/mutate elements of a list whether the list is global or not. If you choose to use a global integer variable, then you always have to declare it is global inside your helper function to update it. Otherwise, you code will throw an error. Oh, and the global variables must be defined outside of the class. Code example below:
res = 0
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
def helper():
global res
if not root: return -1
left = helper(root.left)
right = helper(root.right)
res = max(res, 2+left+right)
...
You may argue what if we pass res as a helper function's argument like "def helper(res):" and then can we avoid declaring that it is global? The answer is no. When you pass the variable as a function's argument, then it will only create a copy of the global variable that is in a different memory location from the global variable. This will result in keeping the global variable "res" unchanged the whole time. If you want to dig deeper on this, refer to this documentation. www.dataquest.io/blog/tutorial-functions-modify-lists-dictionaries-python/.
@@sf-spark129 Thanks for the doc link
@@sf-spark129 thanks for this! i was wondering the same thing
after watching the code, the video is actually very clear. Thanks a lot.
can someone explain why, res has to be a list?
Hi need code really amazing stuff, can i jsut check why is there a need to assign res =[0], instead of res=0
I guess because of scoping? Python creates a new variable in the local scope, so in order to use the global res you need the array to be a container? I guess... lol
-1 and 2+ is redundant complexety.
JS solution:
var diameterOfBinaryTree = function(root) {
let result = 0;
const recurciveSearch = function (node) {
if (!node) {
return 0;
}
const left = recurciveSearch(node.left);
const right = recurciveSearch(node.right);
result = Math.max(result, left + right);
return 1 + Math.max(left, right);
}
recurciveSearch(root);
return result;
};
@@TwoInaCanoe thanks
Не ожидал вас здесь увидеть)
why cannot we define a simple variable to store max but doing it as *res[0]* ? Not able to find answer in the web for this. I know i am missing something related to variables, lists and their behaviour with scopes.
yeah someone asked the same question below, apparently you can't modify a variable when you define it in the outer scope. You can modify elements of a list however, hence the usage of a single element list.
@@thndesmondsaid but his method of defining the list didn't work for me too. I had to declare the self.diameter first.
inclusion of -1 for empty node makes it complicated:
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
res=0
def dfs(root):
nonlocal res
if not root:
return 0
left=dfs(root.left)
right=dfs(root.right)
res=max(res, left+right)
return 1+max(left,right)
dfs(root)
return res
res =[0]
I tried to change it to res =0, but failed because "reference before assignment", why a list can help solve the reference issue?
I tried the same thing. It is something to do with global variables, but I couldn't get it to work with just a standard int. Not sure why setting res to an array makes the difference.
class Solution:
def diameterOfBinaryTree(self, root: TreeNode) -> int:
res = 0
def dfs(root):
if not root:
return -1
left = dfs(root.left)
right = dfs(root.right)
nonlocal res
res = max(res, 2 + left + right)
return 1 + max(left, right)
dfs(root)
return 0 if res == 0 else res
@@singletmat5172 I guess because of scoping? Python creates a new variable in the local scope, and will see the out of scope variable as immutable, so in order to use the global res you need the array to be a container? I guess... lol
My solution using recursion:
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
self.diameter = 0
def depth(node):
if not node:
return 0
left_depth = depth(node.left)
right_depth = depth(node.right)
self.diameter = max(self.diameter, left_depth + right_depth)
return 1 + max(left_depth, right_depth)
depth(root)
return self.diameter
I would argue that this task is not Easy but Middle, because there are few gotchas and things one needs to realize.
This was lowkey hard for an easy problem.
Also you don't have to do -2 operation if you use depth instead of height (I'm not sure if these are two same terms). Then depth of Null-node is 0, and depth of Node with no children is 1 (and so on). So in this way you have to only sum 2 depth. Code here:
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
res = 0
def dfs(root: Optional[TreeNode]):
if root is None:
return 0
left_depth = dfs(root.left)
right_depth = dfs(root.right)
nonlocal res
res = max(res, left_depth + right_depth)
return 1 + max(left_depth, right_depth)
dfs(root)
return res
Banger.
Time complexity is O(N). what is the space complexity for this algorithm?
Worst case scenario, space complexity will be O(N) because of recursion stack
Hi,
I tried with another variable let's say t = 0 and used t at max function -----> this is not working showing as a variable is referred without assignment. But it is working with t= [0]. Could you explain why?
You have to use the nonlocal python keyword to do it that way. Otherwise it thinks you're using a variable local to the function, which hasn't been assigned yet.
@@NeetCode Got it!! Thanks a ton.
Using a -1 for null nodes is really smart. If you don't do that, your code ends up in if statement hell. How do you come up with these elegant algorithms?
Imo -1 makes it more confusing, simply said, if there's 1 node in the left, then diameter to the left = 1, so diameter = height left + height right is more clear in this sense
what's the point of writing the result variable as a list? @12:45
I guess because of scoping? Python creates a new variable in the local scope, and will see the out of scope variable as immutable, so in order to use the global res you need the array to be a container? I guess... lol
Can someone explain why we are using a list here like res= [0] for storing the result, instead of self.res= 0?
python scope.
Python will look for the variable to mutate starting from the closest scope, and work its way up. The statement res = res + 1 (aka res += 1) it will evaluate from right to left (res + 1). Python will ask what scope is res defined in so I can access it; ah, I see within my scope I have a res =, so I will use that definition. Back to my res + 1, that res hasn't been defined yet (it's defined same line, which is obviously a syntax error), so I will throw.
The solution is to define res in the same scope, then within the inner scope tell the python interpreter it should look for the higher scoped definition with non local. So you can do:
bar = 1
def foo(x):
nonlocal bar
bar += 1
With neetcodes solution, you never "redefine" the variable, so it just works. Both solutions are unintuitive, but that's what you get with python :/
@@robpruzan7292 Thanks a lot for the detailed explanation 👍 .
I think returning -1 and making 2 + left + right makes it more complicated or at least for me.
The below is working perfectly fine as well.
def dfs(root: Optional[TreeNode]) -> int:
if not root:
return 0
left = dfs(root.left)
right = dfs(root.right)
result[0] = max(result[0], left + right)
return 1 + max(left, right)
first of all, thanks so much for your series and explanations.
@8:44 the 1 + -1 + 2 =1 can be ignored right? or am i tripping
why we return height in the bfs
This the firsrt time ever you over-complicated it lol. But great videos still!
Why does he store the solution in the first index of an array? Could he just use a variable? has something to do with being visible inside the scope of the dfs()?
Amazing explanation
this is basically the max depth problem but you have to find the biggest left+right sum at a node.
Him: "that makes sense, right"
Me: "oh shit, am a dumb ass" 😂
why have you set res=[0], can someone pls explain this?
I guess because of scoping? Python creates a new variable in the local scope, so in order to use the global res you need the array to be a container? I guess... lol
best ever!!
I didn't do the -1 but rather dealt with the null nodes programatically
Hi can you explain why within the dfs function, we need to use "res[0]" instead of just "res"?
Because you cannot modify res inside of a nested function as its a nonlocal variable whereas lists are mutable. If you want to use res you can use nonlocal keyword to declare it inside nested function
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
def dfs(root):
nonlocal res
if not root:
return 0
left = dfs(root.left)
right = dfs(root.right)
res = max(res, left + right + 1)
return 1 + max(left, right)
res = 0
dfs(root)
return res - 1
@@YashGupta-ty2hn You are awesome!
Thanks Glad it helped you
I don't understand why we are using res = [0], instead of res = 0, and referring to it as self.res from within the dfs function, like we have done in other problems. Can anyone explain ?
It's a workaround for python.
The issue with "res = 0" is that YES it will be visible in the inner function "dfs", but when we try to assign a new value to it (eg: "res = 9), it will actually create a new variable "res" with a scope that extends only within this inner function "dfs".
Therefore, his workaround is to use an array, and use the first element as a variable since python won't create a new instance of it ( res [0] )
Update: If you wanted to use "res = 0", make sure to mark it as "global"
You should use nonlocal instead of res[0]
Although we can use a nonlocal....
Using a local would come handy to reuse the function... we cannot expect someone to declare a nonlocal for using this function
how come res = 0 doesn't work but res = [0] does? If I do res = 0 instead, I get a global constant error which I don't get.
class Solution:
def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
Solution.MAX_DIA=0
def dfs(root):
if root is None:
return 0
left=dfs(root.left)
right=dfs(root.right)
Solution.MAX_DIA= max(Solution.MAX_DIA,left+right) #diameter = left + right
return max(left, right)+1
dfs(root)
return Solution.MAX_DIA
Huh! After seeing this I am now confident that I have a chance at DSA.
I just love how the LC introduction to binary trees is really helpful and understandable, then the following questions are like, "Now give me some space-age shit that requires three helper functions".
(Inb4 "ThReE LiTeRaL HeLpEr FuNcTiOnS" - it took one)
Best explanation ever.
why the global variable was inside an array?
I guess because of scoping? Python creates a new variable in the local scope, and will see the out of scope variable as immutable, so in order to use the global res you need the array to be a container? I guess... lol
Well explained, but I don't think it is intuitive to use the "-1" for an empty Node. Instead, we should do what we have always done for empty nodes; return 0.
This would make the code much simpler, as now you can get rid of the "2" and only write "res[0] = max( res[0], left + right )" (which makes more sense imho)
And as mention before, this is consistent with how we usually do DFS.
I think this small part of the code might have confused a lot of people as to why this problem is "Easy"
why use res[0] instead of res = 0
I guess because of scoping? Python creates a new variable in the local scope, so in order to use the global res you need the array to be a container? I guess... lol
Why res = [0] and not just res = 0. I tried it like that and got: UnboundLocalError: cannot access local variable 'dia' where it is not associated with a value
its just the longest left subtree + longest right subtree for any node. recursively
If this is leetcode "EASY" then i guess i have to change my major🤣🤣
Your explanation was super clear. You didn't have to cut that all out at the end. hahah! You are super cute.
lists are automatically global in python
do related BT questions first eg. 110 Balanced Binary Tree and this will seem like an easy (as it should)
Amazing explanation.
I don't get how we use the height here and why we need it.
I am still a bit unclear as to why we need to return the height in the dfs function, can someone help clarify this?
To find the diameter of a node we need the height of the nodes just below it(node.left and node.right).
If anybody is struggling with this and reading this old thread:
The function returns the longest path below any given node. This is because you cannot add diameters of each subtree because the diameter of a subtree does not cross the node above it (hence why the problem specifies that the longest path need not pass through the root -- create a test case where the root has only a left subtree, but that left subtree has two large left and right subtrees. The longest path will not pass through root in this case). Instead, you add longest paths, then calculate the diameter at each step.
The max diameter is calculated as the SUM of the longestPath(left) + longestPath(right)
But the return value of the function is not the diameter, it is the longest path.
If the return value was the diameter itself, we would get outputs way higher than the correct answers because adding diameters would not ensure that it is a valid path.
So the dfs function returns the longest path below any given node. The longest path below the first node is the same as the longest path below the second node PLUS ONE.
The diameter of any node is the sum of the longest path of the left tree and the right tree.
Can somebody hep me figure out why the global variable res is an array instead of an integer? I'm sure it's related to the nature of the data structures but I don't exactly know why we're doing that......
Why does the res have to be res = [0], instead of res = 0 ?? I know that res = 0 doesnt work but dont understand why, can anybody help plz :) ?
I guess because of scoping? Python creates a new variable in the local scope, and will see the out of scope variable as immutable, so in order to use the global res you need the array to be a container? I guess... lol
why the res = [0] and not res = 0? we use it as an integer anyway? didn't quite catch that one
oh so it doesn't work with int type lol