树中的乘法查询

Question

给定一棵包含 N 个节点 (1-N) 的树，每个节点都有一个初始值 A[i]。树的根是节点1。

我们得到Q 类型的查询：

1 V X : multiply all nodes in subtree of `X` with value `V`.
2 X   : find the value of node `X`.  

约束：

N <= 10^5
Q <= 10^5

我的方法：

说，我们有下面的树作为输入：

       1
     /  \
    2    3
   /  \   \
   4  5    7
  /
 6

The idea is to traverse the tree using **DFS** and construct a tree 
traversal array that contains two values for each node.


index        : 0 1 2 3 4 5 6
node         : 1 2 4 6 5 3 7
subtree-size : 7 4 2 1 1 2 1

 and then we create a `segment tree` using above array.

             (0-6)
         /           \
      (0-3)           (4-6)
   /       \         /     \
  (0-1)   (2-3)     (4-5)  (6)
 /   \     /   \    /   \
(0) (1)  (2) (3)   (4)  (5)

--> So now when we get a query of type-1 say, 1 3 2. 
we need to multiply all nodes in 2's sub-tree, which means we need to do a update 
query at (1-4) in our segment tree. 
At each node of a segment tree we keep a initial multiplication factor as 1 and 
update it by multiplying it with the value 'V (in this case = 3)' whenever we get the query of type 1.
--> When we get query of type - 2, say 2 4 : we can now query our 
segment tree at (2, 2) and consolidate all the multiplication factors 
in the path and multiply it with the existing value of node '4' to return the
 result of the query.

使用这种方法，每个查询都可以使用时间O(log(n)) 来解决。我无法按时编写这种方法。

是否有任何其他更简单的方法来解决这个问题（可能不使用 seg-tree）并且根据约束查询时间应该至少与O(log(n))时间一样有效。

Answer 1

算法

首先执行一些预处理来构建树：

• 从边缘构建邻接列表
• 使用邻接表执行深度优先遍历，从根开始，识别每个节点的父节点。这可以存储在一个数组中，这样parents[i] 保存节点i 的父节点的索引，如果它存在，或者如果它没有父节点，则为-1。后者仅适用于根。
• 创建一个数组来存储每个节点的乘法因子，每个节点初始化为 1。

然后执行查询：

• 如果查询是类型 1，则将给定节点的已知因子乘以给定值。这需要固定的时间。
• 如果查询是类型 2，则累积从给定节点到根的路径上找到的因子（使用 parents 数组）。最后输出这个累积因子和给定节点的（原始）值的乘积。这具有 O(logn) 平均时间复杂度。

示例

这是一个示例输入（您确实应该提供！），但它是基于 0 索引的，因为这在编程语言中更为常见。所以根节点用索引0标识：

values: [2, 1, 4, 9, 3, 5]
edges: [[0, 1], [0, 2], [1, 3], [1, 4], [2, 5]]
queries: [
    [2, 2],
    [1, 3, 2],
    [2, 5],
    [1, 10, 0],
    [2, 5],
    [2, 1],
]

这表示以下树：

               2
             /   \
            1     4
           / \   /
          9   3 5

当所有查询都执行完毕后，树可以这样表示，其中每个节点都伴随着一个因子：

               2(10)
             /   \
            1     4(3)
           / \   /
          9   3 5

查询的预期输出是：

4
15
150
10

实施

以下是 JavaScript 中的示例实现。同样，这是使用基于 0 的索引。它运行上面的示例输入。

// Helper function for building the adjacency list
function dfs(adj, parents, node) {
    for (let child of adj[node]) {
        if (parents[child] == -2) { // Not yet visited
            parents[child] = node;
            dfs(adj, parents, child);
        }
    }
}

// Main function to create the adjacency list
function prepare(values, edges) {
    let adj = values.map(value => []); // For each node an empty list (vector)
    
    // Populate the adjacency lists from the given edges
    for (let [u, v] of edges) {
        // Register edge in two directions
        adj[u].push(v);
        adj[v].push(u);
    }
    
    let parents = Array(values.length).fill(-2); // Parents are unknown
    parents[0] = -1; // It is a given that the root is at 0: it has no parent
    dfs(adj, parents, 0); // Identify all other parents
    return parents;
}

// Two functions for performing two types of queries
function multiply(values, parents, factors, factor, i) {
    factors[i] *= factor;
}

function calculate(values, parents, factors, i) {
    let factor = 1; 
    // Walk up the tree to accumulate the applicable factors
    for (let j = i; j > -1; j = parents[j]) {
        factor *= factors[j];
    }
    return values[i] * factor;
}

function solve(values, edges, queries) {
     // Preprocessing:
    let parents = prepare(values, edges);
    let factors = Array(values.length).fill(1); // All factors start as 1
    // Execute the queries:
    for (let query of queries) {
        if (query[0] == 1) {
            multiply(values, parents, factors, query[1], query[2]);
        } else {
            let value = calculate(values, parents, factors, query[1]);
            console.log(value);
        }
    }
}

// Example input:
let values = [2, 1, 4, 9, 3, 5];
let edges = [[0, 1], [0, 2], [1, 3], [1, 4], [2, 5]];
let queries = [
    [2, 2],  // => 4
    [1, 3, 2],
    [2, 5], // => 15 (=5*3)
    [1, 10, 0],
    [2, 5], // => 150 (=5*3*10)
    [2, 1], // => 10 (1*10)
];

solve(values, edges, queries);