二叉树分解子问题练习 LeetCode 1372. 二叉树中的最长交错路径 1373 二叉搜索子树的最大键值和

leetcode1372

思路：
对每一个节点 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在内的数量
    }
};

leetcode1373

思路：
递归解决。
整个思路就是：
当 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 ) ;
        }
    }
};