Well, I think it's solvable in $$$O(N*log^2(N))$$$ using HLD.

For simplicity we'll iterate among nodes from $$$1..N$$$

At each node $$$u$$$ let's divide the task of calculating values in two parts.

1. For all nodes $$$v$$$ which are in subtree of $$$u$$$.
2. For all nodes $$$v$$$ which are not in subtree of $$$u$$$.

Let $$$r$$$ be the root of the tree (though it's given that it would be 1 always, but we'll go with this notation from here on). Let $$$cnt[x]$$$ denote number of nodes in subtree of $$$x$$$ which are less than equal to $$$x$$$. Note that since we are iterating from $$$1...N$$$ among nodes, keeping this count should be fairly simple. Let $$$val[x]$$$ denote the given $$$values$$$ at each node.

Part 1 is fairly simple which is given by $$$cnt[u]*val[u]$$$.

Now the part 2 at each node $$$u$$$ is given by for each node $$$v$$$ in path from $$$u$$$ to $$$r$$$,

$$$sum$$$ = $$$cnt[v]*(val[v]-val[parent[v]])$$$

Let $$$a[x]$$$ denote $$$val[x]-val[parent[x]]$$$.

Thus now simply $$$sum$$$ = $$$cnt[v]*a[v]$$$.

hence $$$ans[u]$$$ = $$$sum$$$ + $$$cnt[u]*val[u]$$$

Thus above formulae is a standard range query thing which can be effectively calculated using Segment tree with lazy Propagation. Thus a HLD using Segment tree is enough to answer.

Hence for each Node $$$u$$$, we get the $$$ans[u]$$$ in $$$O(log^2N)$$$ (segment tree and HLD chain Traversal).

There are $$$N$$$ such nodes hence final complexity is $$$O(N*log^2(N))$$$.

Unless I'm mistaken, there's a very simple $$$O(N)$$$ DFS solution. Rough code is below, but the basic idea is to compute the subtree sizes, then perform a DFS. We store a preliminary answer counting the total answer for nodes not in our current subtree, which allows us to compute the answer for each vertex once we visit it. Running dfs(0, 0) after computing subtree sizes (doable through a separate DFS) gives the answer.

int subtreeSize[N]; //Precompute this
ll V[N];
ll ans[N];
vector<vector<int> > children;

void dfs(int v, ll preliminaryAns) {
    ans[v] = preliminaryAns + V[v] * subtreeSize[v];
    for (int nxt : children[v]) {
        dfs(nxt, preliminaryAns + V[v] * (subtreeSize[v] - subtreeSize[nxt]);
    }
}