树 on 一共十七划

题解-每棵子树内缺失的最小基因值

Tue, 07 Nov 2023 15:33:00 +0800

每棵子树内缺失的最小基因值

题目简介

有一棵根节点为 0 的家族树，总共包含 n 个节点，节点编号为 0 到 n – 1 。给你一个下标从 0 开始的整数数组 parents ，其中 parents[i] 是节点 i 的父节点。由于节点 0 是根，所以 parents[0] == -1 。

总共有 $10^5$ 个基因值，每个基因值都用闭区间 $[1, 10^5]$ 中的一个整数表示。给你一个下标从 0 开始的整数数组 nums ，其中 nums[i] 是节点 i 的基因值，且基因值互不相同。

请你返回一个数组 ans ，长度为 n ，其中 ans[i] 是以节点 i 为根的子树内缺失的最小基因值。

节点 x 为根的子树包含节点 x 和它所有的后代节点。

思路

在概念上与41. 缺失的第一个正数题类似,都是找数,由于本题没有要求O(1)O(1)O(1)的空间复杂度,所以用哈希表是可能的
与数组中缺失的第一个正数类似的是,如果一棵树的节点不包括1,则以该树的任意节点为根的的子树都缺少1,这是最简单的情况
对于子节点有1的才是重要讨论的情况

解题方法

注意到需要处理的只是根节点到基因值为1的这一段的每个节点
- 注意到此时讨论的只是一条链
- 其他的节点的缺失值一定为1
可以用哈希表记录以该节点为根的子树包含的所有基因值,然后再每个节点都遍历一下
上述复杂度很高,再仔细观察节点的哈希表的形式,可以知道父节点的哈希表是所有子节点的合集加上自己的基因数
- 所以我们只需要自底向上遍历,维护一个哈希表就可以了
- 注意到父节点缺失的值不可能比子树缺失的还小,所以也需要维护一个基因数
时间复杂度:$O(n)$
空间复杂度:$O(n)$

代码

class Solution:
    def smallestMissingValueSubtree(self, parents: List[int], nums: List[int]) -> List[int]:
        n=len(parents)
        res=[1]*n #默认最有可能缺1
        if 1 not in nums:
            return res
        graph=[[]for _ in range(n)]
        for i in range(1,n):
            graph[parents[i]].append(i)
    visited=set()  
    def dfs(index):
        visited.add(nums[index])
        for child in graph[index]:
            if nums[child] not in visited:
                dfs(child)

    root=nums.index(1) #找分界点
    now=2
    while root&gt;=0: #自底向上递归查找
        dfs(root)
        while now in visited:
            now+=1
        res[root]=now
        root=parents[root]
    return res</code></pre>

其他
这个理论上不能用与41题类似的将数组本身化为哈希表的操作,不然代码的复杂性很高,而且也不好理解



题解-有向图访问计数,一个有向基环树的简单应用
Sat, 14 Oct 2023 08:27:00 +0800
> Problem: 2876. 有向图访问计数
思路
– 注意到这个图一定有环,而且每个点的出度都为1
– 由题意可知从任意节点出发其都能访问到相关的环
– 答案只分为两个情况:
    – 点在环上,此时能访问的点只有环上的点,不可能出环,答案为环的长度
    – 点在环外,除了环本身之外,其能访问本节点到环的几个节点,答案为环的长度加上其到环的距离
– 注意到可能有多个环相互独立存在,但是不可能出现两个环连通,所以几个图之间互相并不干扰
解题方法
1. 由以上思路得到基本想法,遍历解决每一个单独的环即可
2. 选择一个没有访问的节点,开始访问,其一定能进入环
    1. 记录初次访问访问点的深度
    2. 判断是否已经入环的方法就是判断该节点是否已经访问过
3. 对于当前点已经访问过有两种情况:
    1. 当前节点在之前的旧图上就访问过:此时根据访问深度加上之前已经得出点的答案来更新答案数组
    2. 当前节点是在这个新图上访问两次:此时第二次访问深度减去节点访问深度就是环的长度,更新环上节点的答案,环外带上的节点根据访问深度加环的长度更新
4. 持续上述操作直到所有节点都访问过,因为我们每次都将单个有环图的所有节点处理,所以每个节点都已经处理
> 时间复杂度,$O(n)$
> 空间复杂度,$O(n)$
代码
,对于这种问题应该可以补一个快慢指针法,但是此处没有做
class Solution:
    def countVisitedNodes(self, edges: List[int]) -> List[int]:
        n=len(edges)
        res=[-1]*n
        visited=set()
        for i in range(n):
            if i in visited:
                continue
            now=begin=i #记录begin就不用做反图,直接顺序遍历就能找到答案
            tmp=dict()#记录此次遍历的时候访问的点
            index=0
            while now not in visited:
                tmp[now]=index
                visited.add(now)
                index+=1
                now=edges[now]
            # 此时我们访问了的图有三种可能,一条带,一个环,一个有带的环
            # 后两种可能都是如下解法
            if now in tmp:
                #此时tmp[now]长度为点到环的长度
                belt=dict()
                circle=set()
                length=tmp[now]
                now=begin
                while length>0:
                    belt[now]=length
                    length-=1
                    now=edges[now]
                while now not in circle:
                    circle.add(now)
                    now=edges[now]
                r=len(circle)#环的长度
                for u in tmp:
                    res[u]=r if u in circle else r+belt[u]
            # 第一种可能是比较好处理的
            else:
                #说明连接到了之前的有向基环树上,直接与已经访问的点相加即可
                length=index
                baseLength=res[now]
                now=begin
                while length>0:
                    res[now]=baseLength+length
                    now=edges[now]
                    length-=1
    return res</code></pre>



题解-在二叉树中分配硬币-深度优先搜索,自底向上考虑
Fri, 14 Jul 2023 23:46:22 +0800

Problem: 979. 在二叉树中分配硬币


思路

考虑最后计算成本的时候实际上是计算的是每个节点对硬币的操作数
每个节点只需要一个硬币,如何确定多出来的或少的硬币的流向
考虑自底向上,叶子节点只需要一个硬币,这样就能向父节点要硬币或者向父节点送硬币,之后父节点变成了叶子节点(其子节点已完成使命)
设一个值为$Need$表示需要向上移或者向上要的硬币数,根据以上推论我们能够得到如下公式,正数表示需要向上移动,负数表示需要上方向下移动
$$Need_{节点}=Need_{子节点}+val-1$$
每次将一个节点处理完就将Need的绝对值加入到操作数之中

Code
class Solution:
    def distributeCoins(self, root: Optional[TreeNode]) -> int:
        self.res=0
        def dfs(node:TreeNode):
            if node==None:
                return 0
            left=dfs(node.left)
            right=dfs(node.right)
            self.res+=abs(left)+abs(right)
            return right+left+node.val-1
        dfs(root)
        return self.res
class Solution {
public:
    int res=0;
    int dfs(TreeNode* root){
        if (!root) return 0;
        int left=dfs(root->left);
        int right=dfs(root->right);
        res+=abs(left)+abs(right);
        return left+right+root->val-1;
    }
    int distributeCoins(TreeNode* root) {
        dfs(root);
        return res;
    }
};