CF1092 --- Tree with Maximum Cost

题干

You are given a tree consisting exactly of $n$ vertices. Tree is a connected undirected graph with $n−1$ edges. Each vertex $v$ of this tree has a value $a_v$ assigned to it.

Let $dist(x,y)$ be the distance between the vertices $x$ and $y$. The distance between the vertices is the number of edges on the simple path between them.

Let's define the cost of the tree as the following value: firstly, let's fix some vertex of the tree. Let it be $v$. Then the cost of the tree is $\sum\limits_{i=1}^{n}dist(i, v)a_i$

Your task is to calculate the maximum possible cost of the tree if you can choose $v$ arbitrarily.

$\mathcal{Input}$

The first line contains one integer $n$, the number of vertices in the tree $(1\leq n\leq 2⋅10^5)$.

The second line of the input contains $n$ integers $a_1,a_2, \cdots ,a_n \; (1\leq a_i\leq 2⋅10^5)$, where $a_i$ is the value of the vertex $i$.

Each of the next $n−1$ lines describes an edge of the tree. Edge $i$ is denoted by two integers $u_i$ and $v_i$, the labels of vertices it connects $(1\leq u_i,v_i\leq n, u_i\not= v_i).$

It is guaranteed that the given edges form a tree.

$\mathcal{Output}$

Print one integer — the maximum possible cost of the tree if you can choose any vertex as $v$.

$\mathcal{Example}$

$Case_1$

$Input$

8

9 4 1 7 10 1 6 5

1 2

2 3

1 4

1 5

5 6

5 7

5 8

$Output$

121

$Case_2$

$Input$

1

1337

$Output$

0

$\mathcal{Note}$

Picture corresponding to the first example:

You can choose the vertex $3$ as a root, then the answer will be $2⋅9+1⋅4+0⋅1+3⋅7+3⋅10+4⋅1+4⋅6+4⋅5=18+4+0+21+30+4+24+20=121$.

In the second example tree consists only of one vertex so the answer is always $0$.

$\mathcal{Tag}$

dfs and similar dp tree *1800

思路分析

本题要求解的是，对于树中所有结点，以该节点为根的情况下计算费用，并求费用的最大值。注意在结点非常多的情况下，要考虑$int$溢出的问题，故开$long\;long$(坑死我了)

暴力想法

暴力想法很简单，很类似CF1324 --- Maximum White Subtree，这里直接搬运那个题解里面的图片

对于任意结点，分别计算不同路径的位置，根据树数据结构的特点，可以把贡献分为:

上层父祖先节点贡献
下层子孙结点贡献

然后就是，如何把暴力$dfs$，通过记忆化实现算法优化。

算法优化

我们先求解下层子孙结点的贡献，通过题目我们知道，从结点$v$转移到结点$u$，其中增量的就是以$v$为根结点，其子树中所有结点值的和。其中$a_i$代表结点$i$的值，我们设$f_i$代表以$i$结点为子树根结点，该子树所有结点的和。我们设$hp_i$代表以$i$结点的下层子孙贡献值,这样我们可以写出下层子孙结点贡献值的转移表达值:

\[f[u] = f[v] + a[u]
\]

\[hp[u] = hp[v] + f[v]
\]

现在我们解决了下层得想办法解决更加困难的上层了，对于这类换根dp问题，常用的手段是用利用父节点的值进行状态转移。在这里我们设$dp_i$为结点$i$的最终费用。因此对于某一节点(非根结点)，该节点的最终费用可以表示为:

\[dp[cur] = dp[fa] - hp[cur] - f[cur] + f[fa] - f[cur] + hp[cur] = dp[fa] + f[fa] - 2*f[cur]
\]

上述表达式的意思为:父节点刨去结点$cur$的费用值($dp[fa] - hp[cur] - f[cur]$，加上增量($f[fa] - f[cur]$, note 这里的f[fa],代表着所有的结点和)，再最后加上下层子孙结点贡献值($hp[cur]$).

\[dp[v] = \left\{\begin{array}
1hp[v] & if\; v = root \\
dp[fa] + f[fa] - 2*f[v] & if\; v \not= root\\
\end{array}\right.
\]

&emps;因此我们最终的思路还是为:

从下往上树形$dp$,计算$f_v$,$hp_v$
从上往下换根$dp$,计算$dp_v$

代码

#include<bits/stdc++.h>

using namespace std;

using LL = long long;

using  VL = vector<LL>;

using  VVL = vector<VL>;

LL mx = 0x8000000000000000;

VL a, f, hp, dp;

VVL e;

void dfs(int x, int fa = -1)

{

    f[x] =  a[x], hp[x] = 0;

    for (auto to : e[x])

    {

        if (to == fa) continue;

        dfs(to, x);

        f[x] += f[to];

        hp[x] += (hp[to] + f[to]);

    }

}

void rdfs(int x, int fa = -1)

{

    dp[x] = hp[x];

    mx = max(mx, dp[x]);

    for (auto to : e[x])

    {

        if (to == fa) continue;

        hp[to] = dp[x] + f[x] - 2*f[to];

        f[to] = f[x];

        rdfs(to, x);

    }

}

int main()

{

    int n;

    cin >> n;

    a = f = hp = dp = VL(n);

    e = VVL(n);

    for (auto &x : a) cin >> x;

    for (int i = 0; i < n - 1; ++ i)

    {

        int x, y;

        cin >> x >> y;

        -- x, -- y;

        e[x].push_back(y);

        e[y].push_back(x);

    }

    dfs(0);

    rdfs(0);

    cout << mx << endl;

    return 0;

}

做了两次了，这个1092是自己手打的，还是有进步。WA了一次是没有考虑到整数溢出的情况以后得多加考虑。

以后对于每个根结点都要求的题，考虑优先换根dp。