【第250场周赛】leetcode1938.查询最大基因差-CSDN博客

本文链接：https://blog.csdn.net/jqq125/article/details/118899517

这篇博客介绍了如何通过构建字典树来解决有根树中节点间最大基因差的查询问题。具体方法是深度优先遍历树，并在遍历过程中插入、查询和删除节点以计算每个查询的最大基因差。解答中定义了Trie类来实现字典树，并给出了Solution类作为主要的解决方案，包括maxGeneticDifference方法。整个过程结合了离线查询和二进制位操作，有效地处理了所有查询。

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

题目:
给你一棵 n 个节点的有根树，节点编号从 0 到 n - 1 。每个节点的编号表示这个节点的独一无二的基因值（也就是说节点 x 的基因值为 x）。两个基因值的基因差是两者的异或和。给你整数数组 parents ，其中 parents[i] 是节点 i 的父节点。如果节点 x 是树的根，那么 parents[x] == -1 。

给你查询数组 queries ，其中 queries[i] = [nodei, vali] 。对于查询 i ，请你找到 vali 和 pi 的最大基因差，其中 pi 是节点 nodei 到根之间的任意节点（包含 nodei 和根节点）。更正式的，你想要最大化 vali XOR pi 。

请你返回数组 ans ，其中 ans[i] 是第 i 个查询的答案。
在这里插入图片描述

思路：
字典树，参考官方解答

解答：

class Trie:
    def __init__(self):
        self.left=None
        self.right=None
        #cnt:记录该节点对应的数的个数
        self.cnt=0

class Solution:    
    MAXD = 17
    def maxGeneticDifference(self, parents: List[int], queries: List[List[int]]) -> List[int]:
        # 最大的数的二进制表示不会超过 18 位,那么二进制位的下标范围为 [0, 17]
        #将 parents 存储为树的形式，方便进行深度优先遍历
        edges = defaultdict(list)
        # 找出根节点
        root = -1
        for i, parent in enumerate(parents):
            if parent == -1:
                root = i
            else:
                edges[parent].append(i)
        
        q = len(queries)
        # 使用离线的思想，stored[i] 存储了所有节点 i 对应的询问
        stored = defaultdict(list)
        ans = [0] * q
        for i, (node, val) in enumerate(queries):
            stored[node].append((i, val))
        
        r = Trie()

        # 向字典树添加一个数
        def trie_insert(x: int) -> None:
            cur = r
            for i in range(Solution.MAXD, -1, -1):
                #若x的最高位为1，则将其置于右子树
                if (x>>i) & 1:
                    if not cur.right:
                        cur.right = Trie()
                    cur = cur.right
                #若x的最高位为0，则将其置于左子树
                else:
                    if not cur.left:
                        cur.left = Trie()
                    cur = cur.left
                cur.cnt += 1

        # 对于给定的 x，返回字典树中包含的数与 x 进行异或运算可以达到的最大值
        def trie_query(x: int) -> int:
            cur, ret = r, 0
            for i in range(Solution.MAXD, -1, -1):
                #若x的最高位为1，看左子树是否存在（即0是否存在）
                if (x>>i) & 1:
                    if cur.left and cur.left.cnt:
                        #|表示按位或
                        ret |= (1 << i)
                        cur = cur.left
                    else:
                        cur = cur.right
                #若x的最高位为0，看右子树是否存在（即1是否存在）
                else:
                    if cur.right and cur.right.cnt:
                        ret |= (1 << i)
                        cur = cur.right
                    else:
                        cur = cur.left
            return ret

        # 从字典树中删除一个数
        def trie_erase(x: int) -> None:
            cur = r
            for i in range(Solution.MAXD, -1, -1):
                if (x>>i) & 1:
                    cur = cur.right
                else:
                    cur = cur.left
                cur.cnt -= 1

        # 深度优先遍历
        def dfs(u: int) -> None:
            trie_insert(u)
            for idx, num in stored[u]:
                ans[idx] = trie_query(num)
            for v in edges[u]:
                dfs(v)
            trie_erase(u)

        dfs(root)
        return ans