思路:
对每一个节点 rt , 其最长交错路径可能有2种情况:
以rt 为根:
再细分可分为,第一条边是通往右孩子、或者左孩子
非rt为根:
和上面一样,第一条边通往右孩子、左孩子。
共4种情况。
每一个节点都需要考虑这4种情况,故递归解决,分解为子问题。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int res ;
typedef pair<int,int>P;
int longestZigZag(TreeNode* root) {
res = 0 ;
getres(root);
return res - 1 ;
}
P getres( TreeNode* rt ){
// first : 第一条边通往左孩子的最长交错路长度
// second : 第一条边通往右孩子的最长交错路长度
if( !rt ) return P(0,0) ;
P l = getres( rt -> left );
P r = getres( rt -> right );
res = max( l.second + 1 , res ) ; // 以rt为根,第一条边方向分2种
res = max( r.first + 1 , res ) ;
res = max( l.first , res ) ; // 非rt为根,第一条边方向分2种
res = max( r.second , res ) ;
return P( l.second + 1 , r.first + 1 ) ; // 返回包含rt在内的数量
}
};
思路:
递归解决。
整个思路就是:
当 rt 节点 的左右孩子满足二叉树性质时,如果rt左子树是BST,同时右子树也是BST,那么以rt为根的子树的答案就变成了左右子树的答案和+rt->val 。
这样就可以递归每个左右孩子的解。
全局变量res记录递归满足要求的最大和。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int res ;
typedef pair<int,int>P ;
int maxSumBST( TreeNode* rt ) {
res = 0 ;
getres( rt ) ;
return res ;
}
P getres( TreeNode* rt ){
int ans = 0 ;
if( !rt ) return P(ans , 1) ;
P l = P( 0 , 1 ) , r = P( 0 , 1 ) ;
l = getres( rt -> left );
r = getres( rt -> right ) ;
if( ( rt -> left && rt -> val <= rt -> left -> val ) ||
( rt -> right && rt -> val >= rt -> right -> val ) || // rt不满足BST
( rt -> right && !r.second ) || // 左右子树不满足BST
( rt -> left && !l.second )
) {
return P( 0 , 0 );
}else{
ans += l.first + r.first + rt -> val ;
res = max( res , ans ) ;
return P( ans , 1 ) ;
}
}
};