Review the blog:
Practice on May 31, 2016, first version:
Second version: add more comment:
The above second version line 133 - line 137 can be simplified as one statement:
int value = root.val + ((left>0)?left:0) + ((right>0)?right:0);
Third version: line 133 - line 137 -> one line
Reasoning and analysis (I):
Write some reasoning and analysis.
Let us talk about an example first:
In the practice on May 31, 2016, line 60 - 79, test case 3:
The maximum path sum in the above tree is highlighted using red color, node 6->9->-3->2->2. Any two nodes in the tree can form a unique path, and the choice of path is N^2, N is the total nodes in the tree.
If we do not use recursive solution, try to use brute force solution:
1. Find any two nodes in the tree, and then find the path, and calculate the sum of path.
(June 24, 2016 but least common ancestor is much more difficult problem to solve!)
For example, maximu path, we have to find the common ancestor of those two nodes with value 6 (root->left) and node with value 2 (root->right->right->left) first, and then, the path can be formed.
So, the recursive solution can be based on the following facts:
1. Any node in the tree can be visited from top to down, preorder traversal, once. And the node is treated as root node of one subtree.
2. So, just consider the maximum path starting from root node, this way, the recursive function can be set up.
2. Any two nodes in the tree -> the root to any node in the tree (simplify the case)
3. the maximum path in the above diagram: 6->9->-3->2->2 -> construct by the root to any node in the tree.
value1: Root node with value 9,
value2: Root-> left node's maximum value of "the root to any node in the tree"
value3: Root-> right node's maximum value of "the root to any node in the tree"
the maximum path = value1 +(value2>0?value2:0) + (value3>0?value3:0)
So, the recursive solution can be formed quickly.
August 4, 2016
Come back to review the previous work, but it is still not easy to tell the ideas to solve the problem.
Reasoning and analysis (II):
Add one more explanation to walk through the example:
First talk about "maximum value cross root" - variable: maxValueCrossRoot,
each node is the root of its subtree, so the maximum one will be maximum one from the following list:
1. n1: root node (9): need to calculate maximumEndByRoot on right child (-3) first.
2. n2: left child (6):
3. n3: right child (-3):
4. n4: right->right child(-6): -6
5. n5: right->right->right (2): 4
6. n6: right->rigth->right->left(2) : 2
7: n7: right->right->right->left->left(-6): -6
8: n8: right->rigth->right->left->right(-6): -6
It is comparison by values.
Tip: 1.The idea to get the maximum value is to pass a reference int to any recursive function. Any subtree will have one value, and compare with the global variable's value.
2. Use preorder traversal to travel tree once.
And "maximum value end by root" - variable: maximumEndByRoot
the above node n8: -6
So, the root node maxValueCrossRoot = 9 + 6 + 1 = 16
maximumByEnd = 15.
Tip: 1. use recursive function with return value - maxValueEndByRoot, the formula is easy to recall.
2. use preorder traversal to travel tree once.
The above case is coincident, the maxValueCrossRoot is ended at the root node n1 (value 9), which may be anywhere (ni, i is one value from 1 to 8) in the tree.
Reasoning and analysis (III):
Creative way to solve the problem:
Maximum value end by root in a binary tree - in other words, maximum value from the root node to any node in binary tree
Goal: be able to write the function in 10 minutes, verify code with static analysis.
2. Add one more function in the above program -
Based on the simple problem - maximum value end by the root node, add one more task to the function:
maxValueCrossRoot calculation. (bottom up solution)
Add 2 more lines of code: line 104, 105, add one more input argument - ref int maxCrossRoot, 3 places update
Goal: make it 10 minutes to add
So, overall, it should be less than 20 minutes code writing. Follow the function - do one task
1. Step 1: write a simple recursive function - preorder traversal. Pay attention to negative value node, just ignore them if it is. Avoid if statement, just get minimum value through 3 values, make it one line statement - no if/else discussion of left/right child value > 0.
Only 5 lines of code. Short and concise.