《六月集训》（第十八天）——树

前言

        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        今天是六月集训第十八天：树

一、练习题目

        1361. 验证二叉树
        1367. 二叉树中的列表
        1457. 二叉树中的伪回文路径
        1373. 二叉搜索子树的最大键值和

二、算法思路

• 1、1361. 验证二叉树:理清思路考虑几个判断条件。递归的去搜索即可。
• 2、1367. 二叉树中的列表：
• 3、1457. 二叉树中的伪回文路径：
• 4、1373. 二叉搜索子树的最大键值和：

三、源码剖析

// 1361. 验证二叉树
class Solution {
    int hash[10010];
    void dfs(vector<int>& leftChild, vector<int>& rightChild, int x) {
        hash[x] = 1;
        if(leftChild[x] != -1) {
            dfs(leftChild, rightChild, leftChild[x]);
        }
        if(rightChild[x] != -1) {
            dfs(leftChild, rightChild, rightChild[x]);
        }
    }
public:
    bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
        int deg[10010];
        memset(deg, 0, sizeof(deg));
        memset(hash, 0, sizeof(hash));
        for(int i = 0 ; i < leftChild.size(); ++i) {
            if(leftChild[i] != -1) {
                ++deg[leftChild[i]];
            }
            if(rightChild[i] != -1) {
                ++deg[rightChild[i]];
            }
        }
        int cnt = 0;
        int root = -1;
        for(int i = 0; i < n; ++i) {
            if(deg[i] == 0) {
                if(n == 1) {
                    return true;
                }
                ++cnt;
                root = i;
                if(cnt > 1) {
                    return false;
                }
            }
            if(deg[i] > 1) {
                return false;
            }
        }
        if(cnt == 0) {
            return false;
        }
        dfs(leftChild, rightChild, root);
        for(int i = 0; i < n; ++i) {
            if(!hash[i]) {
                return false;
            }
        }
        return true;
    }
};

• 1、

// 1367. 二叉树中的列表
class Solution {
    bool check(ListNode* head, TreeNode* root) {
        if(root == nullptr) {
            return (head == nullptr);
        }
        if(head == nullptr) {
            return true;
        }
        if(head->val != root->val) {
            return false;
        }
        return check(head->next, root->left) || check(head->next, root->right);
    }
public:
    bool isSubPath(ListNode* head, TreeNode* root) {
        if(root == nullptr) {
            return false;
        }
        if(check(head, root)) {
            return true;
        }
        return isSubPath(head, root->left) || isSubPath(head, root->right);
    }
};

• 1、

// 1475. 商品折扣后的最终价格
class Solution {
public:
    vector<int> finalPrices(vector<int>& prices) {
        int n = prices.size();
        vector<int> ans = prices; //(1)
        for(int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                if (prices[j] <= prices[i]) {
                    ans[i] = (prices[i] - prices[j]); //(2)
                    break;
                }
            }
        }
        return ans;
    }
};

• 1、

// 1373. 二叉搜索子树的最大键值和
class Solution {
    int ret = 0;
    void dfs(TreeNode* root, int *minv, int *maxv, int *sumv, int *isbnf) {
        if(root == nullptr) {
            *minv = INT_MAX;
            *maxv = INT_MIN;
            *sumv = 0;
            *isbnf = 1;
            return ;
        }
        int lminv, lmaxv, lsumv, lisb;
        int rminv, rmaxv, rsumv, risb;
        dfs(root->left, &lminv, &lmaxv, &lsumv, &lisb);
        dfs(root->right, &rminv, &rmaxv, &rsumv, &risb);

        *sumv = root->val;
        if(lmaxv < root->val && rminv > root->val && lisb && risb) {
            *isbnf = 1;
            *sumv = root->val + lsumv + rsumv;
        } else {
            *isbnf = 0;
            *sumv = 0;
        }
        *maxv = max(lmaxv, rmaxv);
        *maxv = max(root->val, *maxv);

        *minv = min(lminv, rminv);
        *minv = min(root->val, *minv);

        ret = max(ret, *sumv);
    }
public:
    int maxSumBST(TreeNode* root) {
        int minv, maxv, sumv, isbnf;
        dfs(root, &minv, &maxv, &sumv, &isbnf);
        return ret;
    }
};

• 1、