CF592D Super M 树形换根dp

CF592D Super M

题意

无根树上给定$m$个点，现在可以以树上任意一个点作为起点，求使得经过所有给定点的路径长度之和最小的起点和路径长度之和

题解

我发现大部分人都是用什么虚树或者树的直径那些来搞的，其实没有必要，考虑换根树形dp
考虑如何计算确定根时的答案：
现在以$rt$为根，需要依次经过所有给定点(标记一下，记为$tag[u]=1$)
先考虑经过所有点并且回到$rt$的情况
对于点$u$来说，如果$tag[u]=1$，那么$rt-u$这段路是需要走两次的(来回)
记$f[u]$为经过$u$的子树中所有标记点并且回到$u$的花费
那么就这样统计：

void dfs(int u, int fa) {
    for (auto &v: g[u])
        if (v != fa) {
            dfs(v, u);
            if (f[v] || tag[v])//如果v是给定点或者v的子树中有给定点, 那么u-v这条边需要经过2次
                f[u] += f[v] + 2;
        }
}

现在回到原来的问题，显然，原问题就是当前问题的答案减去与$rt$距离最远的点的距离，即最远的路只经过一次，其余的路走来回(两次)
所以还要多维护一个东西，子树中最远的标记点到当前点的距离，下面我都用最远距离来表述

考虑到后面我们需要换根，想一下如果换了根之后，最远距离会如何变化
现在以$u$为根，下一个根为$v$
那么如果$u$的子树中最远距离是从$v$中继承过来的
那么当根转移时，$u$的最远距离还能去更新$v$的最远距离吗，显然不能
我们得找到$u$的子树中除了$v$的最远距离
那么其实再维护一个次远距离即可，当最远距离是从v中继承过来时，直接去找次远距离

于是第一遍的$dfs$就是这样：

//mx[u].first为u的子树中最远的标记点到当前点的距离, second为次远距离
void updMax(int u, int val) {//维护最远/次远距离
    if (val > mx[u].first) mx[u].second = mx[u].first, mx[u].first = val;
    else if (val > mx[u].second) mx[u].second = val;
}

void dfs(int u, int fa) {
    for (auto &v: g[u])
        if (v != fa) {
            dfs(v, u);
            if (f[v] || tag[v]) {
                updMax(u, mx[v].first + 1);//维护最远/次远距离
                f[u] += f[v] + 2;
            }
        }
}

换根的$dfs$长这样：

void dfs2(int u, int fa) {
    updAns(u, f[u] - mx[u].first);
    for (auto &v: g[u])
        if (v != fa) {
            pii mxu = mx[u], mxv = mx[v];
            int fu = f[u], fv = f[v];
            int tmx = mxu.first;

			//先将v对u的操作撤回
            if (f[v] || tag[v]) {
            	//如果最远距离是从v继承来的, 那换根后u的最远距离为原来的次元距离
                if (tmx == mx[v].first + 1) tmx = mx[u].second;
                f[u] -= f[v] + 2;
            }

            if (f[u] || tag[u]) {
                updMax(v, tmx + 1);
                f[v] += f[u] + 2;
            }

            dfs2(v, u);
            //还原
            mx[u] = mxu, mx[v] = mxv;
            f[u] = fu, f[v] = fv;
        }
}

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 2e5 + 10;
const int INF = 0x3f3f3f3f;

int n, m;
int tag[N], f[N];
pii mx[N], ans;
vector<int> g[N];

void updMax(int u, int val) {
    if (val > mx[u].first) mx[u].second = mx[u].first, mx[u].first = val;
    else if (val > mx[u].second) mx[u].second = val;
}

void dfs(int u, int fa) {
    for (auto &v: g[u])
        if (v != fa) {
            dfs(v, u);
            if (f[v] || tag[v]) {
                updMax(u, mx[v].first + 1);
                f[u] += f[v] + 2;
            }
        }
}

void updAns(int u, int val) {
    if (ans.first > val) ans.first = val, ans.second = u;
    else if (ans.first == val) ans.second = min(ans.second, u);
}

void dfs2(int u, int fa) {
    updAns(u, f[u] - mx[u].first);
    for (auto &v: g[u])
        if (v != fa) {
            pii mxu = mx[u], mxv = mx[v];
            int fu = f[u], fv = f[v];
            int tmx = mxu.first;

            if (f[v] || tag[v]) {
                if (tmx == mx[v].first + 1) tmx = mx[u].second;
                f[u] -= f[v] + 2;
            }

            if (f[u] || tag[u]) {
                updMax(v, tmx + 1);
                f[v] += f[u] + 2;
            }

            dfs2(v, u);
            mx[u] = mxu, mx[v] = mxv;
            f[u] = fu, f[v] = fv;
        }
}

int main() {

    scanf("%d%d", &n, &m);
    for (int i = 1; i < n; i++) {
        int u, v; scanf("%d%d", &u, &v);
        g[u].push_back(v); g[v].push_back(u);
    }
    for (int i = 1; i <= m; i++) {
        int x; scanf("%d", &x);
        tag[x] = 1;
    }
    ans.first = INF;
    int rt = 1; dfs(rt, 0); dfs2(rt, 0);
    printf("%d\n%d\n", ans.second, ans.first);

    return 0;
}