leetcode337.打家劫舍iii（“树形动态规划”,DP）

• https://leetcode.cn/problems/house-robber-iii/

递归方法

• 求解过程,最终结果res =max(9,8)
  

#include <stdio.h>
#include <algorithm>
#include<vector>
#include<queue>
#include<iostream>
#include<memory>
using namespace std;


//Definition for a binary tree node.
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
//使用数组建立二叉树
TreeNode *CreateBiTree(vector<int> &a, int n, int start)//*a为data，n为数组长度，start为根节点
{
    if (a[start] == -1)return nullptr;//当根节点为空，即空树

    TreeNode* root = new TreeNode(a[start]);//新建一个根结点
    //给根结点root的成员变量data,lchild,rchild赋初值
    root->left = nullptr;
    root->right = nullptr;

    int lnode = 2 * start + 1;//用根节点确定左节点的位置
    int rnode = 2 * start + 2;//用根节点确定右节点的位置

    if (lnode > n - 1) root->left = nullptr;//超出范围为空
    else root->left = CreateBiTree(a, n, lnode);//lnode替换start，为左子树的根节点

    if (rnode > n - 1) root->right = nullptr;
    else root->right = CreateBiTree(a, n, rnode);//rnode替换start，为右子树的根节点

    return root;
}

// 打印二叉树
void out_tree(TreeNode *head){
    if(head!= nullptr){
        cout<< head->val;
        out_tree(head->left);
        out_tree(head->right);
    }
}




class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == nullptr) return root;
        TreeNode* root_right = root->right;//deal with heap use after free
        root->right = invertTree(root->left);
        root->left = invertTree(root_right);
        return root;
    }

    int _rob_(TreeNode *head){ //  c++ 不支持返回值  https://www.zhihu.com/question/497145024/answer/2211413721
    //这样只有前一个值（比如下面的left）能正确赋值
        if(head!= nullptr){
            int left,right ,maxleft,maxright;
            left    =0;  maxleft =0; right= 0; maxright=0;
            if(head->left != nullptr){
                left ,maxleft = _rob_(head->left);
            }  

            if(head->right!= nullptr){
                right ,maxright  = _rob_(head->right);
            } 

            int sum1 = left+right;
            int sum2 = head->val+maxleft+maxright;
            if( sum1 > sum2){
                return sum1, left+right;
            }else{
                return sum2,left+right;
            }
        }
    }


    vector<int> _rob(TreeNode *head){
        if(head!= nullptr){
            int left,right ,subleft,subright;
            left=0;  subleft =0; right= 0; subright=0;
            vector<int> v;
            if(head->left != nullptr){
                v = _rob(head->left);
                left =v[0];subleft =v[1];
            }  

            if(head->right!= nullptr){
                v  = _rob(head->right);
                right=v[0] ;subright =v[1];
            } 

            int sum1 = left+right;
            int sum2 = head->val+subleft+subright;
            if( sum1 > sum2){  // {maxvalue for cur node, sub node for cur like 1 and 3 for 4}
                return {sum1, left+right};
            }else{
                return {sum2,left+right};
            }
        }
    }



    int rob(TreeNode *head){
        int a,b;
        vector<int> res = _rob(head);
        a=res[0];b=res[1];
        return max(a,b);
    }
};



int main()
{
    //Solution *myslo = new Solution();
    unique_ptr<Solution> myslo = unique_ptr<Solution>(new Solution());
    //vector<int> v1 = {3,4,5,1,3,-1,1};
    vector<int> v1 = {3,2,3,-1,3,-1,1};
    TreeNode *tree = CreateBiTree(v1,v1.size(),0);
    out_tree(tree); // 123
    cout<<"*************************************************************"<<endl;
    cout<< myslo->rob(tree) <<endl;

    TreeNode *res = myslo->invertTree(tree);
    out_tree(res); //132
    cout<<"*************************************************************"<<endl;
    //delete myslo;
    return 0;
}

errorsolve

• 后续遍历，从低向上计算，返回当前值或者左右子树值之和的较大一个。
• 这种方式对于用例[3,2,3,N,3,N,-1]返回错误值6

    int rob(TreeNode *head){
        if(head!= nullptr){
            int left,right;
            if(head->left != nullptr){  left  = rob(head->left); }  else{ left =0;}
            if(head->right!= nullptr){  right  = rob(head->right); } else{ right= 0;}
            int sum = left+right;
            if( sum > head->val){
                return sum;
            }else{
                return head->val;
            }
        }
    }

• 后续需要考虑 当前节点 3 和“隔代的子树值” 3+1