【换根dp初学记录】（内附 codeforce例题）

换根dp初学记录

换根dp是一类特殊的树形dp，相关的问题一般和处理每个点作为根节点所需要处理的值的问题。
朴素的想法就是和让每一个点作为根节点，然后利用dfs或者bfs计算所需要求的值，此时时间复杂度会达到恐怖的o($n^2$)，所以这时候就需要用到我们的换根dp
问题链接
给一颗无向树（n个节点，n-1条无向边的连通图），此时需要求出一个结点，使得以这个结点为根时，所有结点的深度之和最大，个结点的深度之定义为该节点到根的简单路径上边的数量。

分析

不难想到我们可以以每个点为根使用dfs算法求出每个节点的深度之和并且得到最大的值，但很显然我们时间复杂度不允许这种o($n^2$)级别的算法，于是我们需要用更加快速的方法使得起复杂度能降低为o(n)。

首先我们可以先让1为根 预处理出来每个点的深度，以及每颗子树i的大小sz[i]，然后我们开始考虑将以1为根的过程转换为以1的子树为根的节点过程产生的变化：
首先将u为根转到子节点v上 ，那么在u子树上的点的深度就可以都减去1,即减去sz[v],然而不在u的子树上而是在u的父节点上的点的深度就需要加一，那么除去v的子树外还剩余n-sz[v]个点，那么深度就需要加上n-sz[v]
由此我们可以可以得到公式 f[v]=f[u]+n-sz[v]-sz[v]
于是我们就可以通过预处理以1为根节点的所有子树大小来计算出所有的子树为根的情况。当然这题还有其他做法如使用树的直径的方法找最大值，这里只展示换根dp的做法
下面展示一些 内联代码片。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<cmath>
using namespace std;
#define int long long 
#define endl "\n"
const int N = 2e6+10;
int n,m,k;
int sz[N],d[N];//sz为子树大小，d为深度
int f[N];//f为每个节点所需要计算出的子树深度和
vector<int>g[N];
void dfs(int u,int fa)//预处理出根节点1以及子树的所有信息
{
    sz[u]=1;
    d[u]=d[fa]+1;
    for(auto j:g[u])
    {
        if(j==fa)continue;
        dfs(j,u);
        sz[u]+=sz[j];
        f[u]+=sz[j];
    }
}
void dfs1(int u,int fa)//使用上面推导出的换根公式
{
    for(auto j:g[u])
    {
        if(j==fa)continue;
        f[j]=f[u]+(n-2*sz[j]);
        dfs1(j,u);
    }
}
void solve()
{
    cin>>n;
    for(int i = 0;i < n-1;i ++)
    {
        int a,b;
        cin>>a>>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(1,0);
    
    dfs1(1,0);
    int ans= 0;
    int t;
    for(int i= 1;i<= n;i ++)
    {
        if(ans<f[i])
        {
            ans=f[i],t = i;
        }
    }
    cout<<t<<endl;
}
signed  main()
{
    ios_base::sync_with_stdio(0); cin.tie(0);cout.tie(0);
   int t=1;
   
   while(t--)
   {
       solve();
   }
    return 0;
}

接下来我们再看一道最近在cf上做到的换根dp的题。
tree xor

简单来说就是计算出以每个点作为根节点，将剩余的所有点变成一样大小的点所需要耗费的最小代价是多少。

问题分析

首先我们先把问题分析分析，我们求出以每个点为根所需要的最小代价，需要把所有子节点变成相同大小，即 ： 将$a_i$ 变化为$a_i\oplus c$，由于我们只能对于子树进行XOR异或操作，所以我们最后一定是要让所有的子树等于根节点的大小。由异或的性质可得到 若：x^c=y，则 c = x^y,则我们以上面换根dp的思路先预处理出一个点以及他所有点子树的信息，然后再通过根部的贡献进行转换。
例如 此时根为u,子树为v，将v转换为根，则子树v的贡献就需要减去sz[v]*(a[u] ^ a[v])，而对于非u子树的点有n-sz[v]个这些点的贡献需要额外加上（n-sz[v])*(a[u] ^ a[v]) 则我们同样可以得到换根的公式 f[v]=f[u]+(n-2*sz[v])*(a[u]^a[v])；
于是我们就可以用上面一样的流程开始敲代码了

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<cmath>
using namespace std;
#define int long long 
#define endl "\n"
const int N = 3e5+10;
int n,m,k;
typedef pair<int,int>PII;
int f[N],sz[N];//f[i]为根所需要的代价，sz[i]为i的子树大小
vector<int>g[N];//存图
int a[N];
void dfs(int u,int fa)//同样的预处理出子树的信息，其实就是处理出以1为根的代价然后利用换根公式进行转移
{
    sz[u]=1;
    for(auto  j:g[u])
    {
        if(j==fa)continue;
        dfs(j,u);
        sz[u]+=sz[j];
        f[u]+=f[j]+sz[j]*(a[u]^a[j]);//这个就是通过回溯我们得到u
    }
    
}
void dfs1(int u,int fa)
{
    for(auto j:g[u])
    {
        if(j==fa)continue;
        f[j]=f[u]+(n-2*sz[j])*(a[u]^a[j]);
        dfs1(j,u);
    }
}
void solve()
{
    cin>>n;
    for(int i= 1;i <= n;i ++)
    {
        g[i].clear();
        cin>>a[i];
        sz[i]=f[i]=0;
    }
    for(int i = 0;i < n-1;i ++)
    {
        int a,b;
        cin>>a>>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs(1,-1);
    dfs1(1,-1);
    for(int i = 1;i<= n; i++)cout<<f[i]<<' ';
    cout<<endl;
    
}
signed  main()
{
    ios_base::sync_with_stdio(0); cin.tie(0);cout.tie(0);
   int t=1;
   cin>>t;
   while(t--)
   {
       solve();
   }
    return 0;
}