leetcode 高效制胜 7 树

最新推荐文章于 2024-09-15 15:29:37 发布

Wuuuuuu2019

最新推荐文章于 2024-09-15 15:29:37 发布

阅读量66

点赞数

文章标签： leetcode 算法树结构

本文链接：https://blog.csdn.net/Wuuuuuu2019/article/details/119902192

版权

本文通过三个经典的二叉树问题——路径总和、二叉搜索树中第K小的元素以及监控二叉树，深入探讨了递归在解决二叉树问题中的应用。对于路径总和，通过递归检查路径和；在寻找二叉搜索树的第K小元素时，利用中序遍历优化；对于监控二叉树，采用自底向上的递归策略确定最少摄像头数量。这些算法展示了递归在二叉树问题中的高效性。

摘要由CSDN通过智能技术生成

112. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。

叶子节点是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
示例 3：

输入：root = [1,2], targetSum = 0
输出：false

提示：

树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr)return false;
        if(root->left==nullptr&&root->right==nullptr&&targetSum==root->val)return true;
        
        return hasPathSum(root->left,targetSum-root->val)|hasPathSum(root->right,targetSum-root->val);
    }
};

递归遍历,so easy

230. 二叉搜索树中第K小的元素

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。

示例 1：

输入：root = [3,1,4,null,2], k = 1
输出：1
示例 2：

输入：root = [5,3,6,2,4,null,null,1], k = 3
输出：3

提示：

树中的节点数为 n 。
1 <= k <= n <= 104
0 <= Node.val <= 104

进阶：如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化算法？

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    struct NewTreeNode{
        int val;
        int count;
        NewTreeNode* left;
        NewTreeNode* right;
        NewTreeNode() : val(0), left(nullptr), right(nullptr) {}
    };

    NewTreeNode* getCount(TreeNode* root){

        if(root==nullptr)return nullptr;
        NewTreeNode *node=new NewTreeNode();
        node->val=root->val;
        node->count=1;
        if(root->left!=nullptr){
            node->left=getCount(root->left);
            node->count+=node->left->count;
        }
        if(root->right!=nullptr){
            node->right=getCount(root->right);
            node->count+=node->right->count;
        }
        return node;
    }

    int getAns(NewTreeNode *node,int k){
        int leftCount=node->left==nullptr?0:node->left->count;
        
        if(k==leftCount+1)return node->val;
        else if(k<=leftCount)return getAns(node->left,k);
        else return getAns(node->right,k-1-leftCount);

    }

    int kthSmallest(TreeNode* root, int k) {
        NewTreeNode *node=getCount(root);
        return getAns(node,k);
    }
};

参考了BST写法，记录结点数
NewTreeNode() : val(0), left(nullptr), right(nullptr) {}
NewTreeNode *node=new NewTreeNode();

递归：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    private int res;
    private int count;

    public int kthSmallest(TreeNode root, int k) {
        inorder(root, k);

        return res;
    }

    public void inorder(TreeNode root, int k) {
        if (root == null) {
            return;
        }

        inorder(root.left, k);

        ++count;
        if (count == k) {
            res = root.val;
            return;
        }

        inorder(root.right, k);
    }
}

作者：superkakayong
链接：https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/solution/zi-jie-ti-ku-230-zhong-deng-er-cha-sou-s-5gth/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

968. 监控二叉树

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

示例 1：

输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。
示例 2：

输入：[0,0,null,0,null,0,null,null,0]
输出：2
解释：需要至少两个摄像头来监视树的所有节点。上图显示了摄像头放置的有效位置之一。

提示：

给定树的节点数的范围是 [1, 1000]。
每个节点的值都是 0。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int ans;
    void dfs(TreeNode* root,bool &cover,bool &haveCamera){
        if(root==nullptr){
            cover=1;
            haveCamera=0;
            return;
        }

        bool lc,rc,lh,rh;
        dfs(root->left,lc,lh);
        dfs(root->right,rc,rh);
        
        if(lc&&rc){
            if(lh|rh){
                cover=1;
                haveCamera=0;
            }else{
                cover=0;
                haveCamera=0;
            }
        }else{
            cover=1;
            haveCamera=1;
            ans++;
        }
        //cout<<ans<<endl;
    }

    int minCameraCover(TreeNode* root) {
        bool cover,haveCamera;
        dfs(root,cover,haveCamera);
        if(cover==0)ans++;
        return ans;
    }
};

还想了蛮久的，刚开始是想从上到下按camera，但是超时，然后决定从下到上
如果子节点都被监控，那么母结点就不装camera，然后判断一下是否被监控
此外都改母结点装监控
注意根节点是否被监控

struct Status {
    int a, b, c;
};

class Solution {
public:
    Status dfs(TreeNode* root) {
        if (!root) {
            return {INT_MAX / 2, 0, 0};
        }
        auto [la, lb, lc] = dfs(root->left);
        auto [ra, rb, rc] = dfs(root->right);
        int a = lc + rc + 1;
        int b = min(a, min(la + rb, ra + lb));
        int c = min(a, lb + rb);
        return {a, b, c};
    }

    int minCameraCover(TreeNode* root) {
        auto [a, b, c] = dfs(root);
        return b;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-cameras/solution/jian-kong-er-cha-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。