The stumbling block here is that for each node, there are *two* things that must be done and two values that must be returned - the node must first figure out what is the longest path it sees (which is simply the sum of the max depth on each side) and it must also report the max depth for it's sub-tree so that it's parent node can figure out what is the longest path *it* can see and if the longest path instead passes though *it* instead of being somewhere in it's left and right subtrees. So each invocation of the function must return a pair - the longest path in that subtree and the max depth of that subtree. In this way, the first call (for root) can get the longest path so far for the left and right subtrees and also the max depths for each side. Then, it can be decided if the longest path is through the root or is in its left subtree or in its right subtree.

Do a dfs from the root to find a vertex that is most distant from the root and call it x. Call a dfs from x to find the most distant vertex from x and return it.

I don't think we can just find height of left and right subtrees and add together + 2. It's possible that there is an even longer path that exists in the left subtree itself. For example, there could be no right subtree at all and only a left subtree which branches out in both the right and left directions. The path with its center at the left subtree would be longer than left+right.

i think we can compute the height of the left sub tree and the height of the right sub tree, then add them together

Define a BST.depth function, call it on the left and on the right subtree, then add the two depths + 2 for the (root.left, root.right) path length.

Depth of Tree ... Use Queue if you want to do iteratively, else use recursion and get the depth.