[hdu7078]Pty with card

显然问题被分为两部分，先考虑如何求$F(n)$——

令第一次所选的人编号为1，其之后所有人按顺时针依次编号为$2,3,...,n$，那么用一个序列来描述状态，其中第$i$个元素为当前存在的人中编号第$i$小的人手牌数（显然序列长度即为剩余人数）

初始序列显然为$\{1,1,...,1\}$（共$n$个1），并对$n$的奇偶性分类讨论：

1.若$n$为奇数，则$n$轮后序列为$\{3,2,2,...,2\}$（其中共$\frac{n-3}{2}$个2）

2.若$n$为偶数，则$n$轮后序列为$\{4,2,2,...,2\}$（其中共$\frac{n}{2}-2$个2）

（关于这个结果，手动模拟若干次即可得到规律）

注意到此时所有元素都$\ge 2$，那么若序列长度为$2m+1$（其中$m\in Z^{+}$），循环节即恰为$4m+2$

关于这个性质，考虑两轮中每一个人都会在奇数轮操作一次、偶数轮操作一次，那么总共即恰好失去3张卡片并得到3张卡片，因此卡牌数量不变，且由于初始有两张卡片，不会有人"出局"

下面，考虑序列长度为$2m$，再对两类分别讨论：

1.若$n$为奇数（注意不是$m$），则$2m$轮后序列为$\{2,3,1,3,1,3...,1,3\}$（其中共$m-1$对$1,3$），再$2m$轮后序列为$\{5,4,4,...,4\}$（其中共$m-1$个4）

不难发现如果序列长度仍是偶数，其又会变为$\{9,8,8,...,8\},\{17,16,16,...,16\},...$（可以归纳证明），直至序列长度为奇数（答案为序列长度的两倍）

2.若$n$为偶数，类似的$4m$轮后序列为$\{6,4,4,...,4\}$（其中共$m-1$个4），如果序列长度仍是偶数，其又会变为$\{10,8,8,...,8\},\{18,16,16,...,16\},...$，直至序列长度为奇数

（另外，若最终序列长度为1则$F(n)=0$）

综上，有
$$F(n)=\begin{cases}0&\left(n\le 2\right)\or \left(lowbit(m)=1\right)\\\frac{2m}{lowbit(m)}&\left(n\ge 3\right)\and \left(lowbit(m)\ne 1\right)\end{cases}$$
（其中$m=\lfloor\frac{n-1}{2}\rfloor$，$lowbit(m)$指$m$二进制下最低位上的1对应的值）

接下来，考虑如何求$\forall 1\le x\le n,\sum_{i=1}^{n}F(v_{i}+d(i,x))$——

将其点分治，问题即是要维护一个集合$S$，支持：1.加入一个元素$x$；2.（给定$x$）查询$\sum_{y\in S}F(x+y)$

这个并不容易维护，但注意到查询中$x$即为某点到当前点分中心的距离，是连续变化的，因此这个问题还可以看作支持：1.加入一个元素$x$；2.令所有元素+1；3.查询$\sum_{x\in S}F(x)$

维护一棵trie树，并且从低到高存储数字，依次考虑这些操作：

1.加入一个元素$x$，与普通的trie树相同

2.令所有元素+1，即不断交换左右儿子，并递归（新的）左儿子即可

3.查询$\sum_{x\in S}F(x)$，不断递归左儿子，维护子树中所有元素的和即可（注意去掉$lowbit(m)=1$的情况）

由此，单次操作时间复杂度为$o(\log n)$，总复杂度即$o(n\log^{2}n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define ll long long
struct Edge{
    int nex,to;
}edge[N<<1];
vector<int>v[N];
int E,rt,t,n,x,y,mx,a[N],head[N],vis[N],sz[N],f[N<<2];
ll ans[N];
int lowbit(int k){
    return (k&(-k));
}
namespace Trie{
    int V,tag,st[N],L[N*6],sz[N*6],ch[N*6][2];
    ll sum[N*6];
    int New(){
        int k=++V;
        L[k]=sz[k]=sum[k]=ch[k][0]=ch[k][1]=0;
        return k;
    }
    ll get(int k){
        return sum[k]+(ll)tag*sz[k];
    }
    void init(){
        V=tag=0;
        New();
    }
    void add_val(int x){
        st[0]=st[1]=1;
        for(int i=0,k=1;i<18;i++){
            int p=((x>>i)&1);
            if (!ch[k][p])ch[k][p]=New();
            k=st[++st[0]]=ch[k][p];
        }
        for(int i=1;i<=st[0];i++)sz[st[i]]++,sum[st[i]]+=x;
        L[st[st[0]]]=st[st[0]];
        for(int i=st[0]-1;i;i--)L[st[i]]=L[ch[st[i]][0]];
    }
    void Add(){
        tag++;
        st[0]=st[1]=1;
        for(int i=0,k=1;(i<18)&&(k);i++){
            swap(ch[k][0],ch[k][1]);
            k=st[++st[0]]=ch[k][0];
        }
        L[st[st[0]]]=st[st[0]];
        for(int i=st[0]-1;i;i--)L[st[i]]=L[ch[st[i]][0]];
    }
    ll query(){
        ll ans=0;
        for(int i=1,k=ch[1][0];(i<18)&&(k);i++){
            ans+=(get(ch[k][1])-get(L[ch[k][1]])>>i-1);
            k=ch[k][0];
        }
        tag--;
        for(int i=1,k=ch[1][1];(i<18)&&(k);i++){
            ans+=(get(ch[k][1])-get(L[ch[k][1]])>>i-1);
            k=ch[k][0];
        }
        tag++;
        return ans;
    }
}
void add_edge(int x,int y){
    edge[E].nex=head[x];
    edge[E].to=y;
    head[x]=E++;
}
void get_sz(int k,int fa){
    sz[k]=1;
    for(int i=head[k];i!=-1;i=edge[i].nex)
        if ((!vis[edge[i].to])&&(edge[i].to!=fa)){
            get_sz(edge[i].to,k);
            sz[k]+=sz[edge[i].to];
        }
}
void get_rt(int k,int fa,int s){
    int mx=s-sz[k];
    for(int i=head[k];i!=-1;i=edge[i].nex)
        if ((!vis[edge[i].to])&&(edge[i].to!=fa)){
            get_rt(edge[i].to,k,s);
            mx=max(mx,sz[edge[i].to]);
        }
    if (mx<=(s>>1))rt=k;
}
void get_val(int k,int fa,int s){
    if (mx<s)v[++mx].clear();
    v[s].push_back(k);
    Trie::add_val(a[k]+s);
    for(int i=head[k];i!=-1;i=edge[i].nex)
        if ((!vis[edge[i].to])&&(edge[i].to!=fa))get_val(edge[i].to,k,s+1);
}
void calc(int k,int p){
    Trie::init();
    mx=0,v[0].clear();
    get_val(k,0,p);
    p=1-(p<<1);
    for(int i=0;i<=mx;i++){
        ll s=Trie::query();
        for(int j=0;j<v[i].size();j++)ans[v[i][j]]+=p*s;
        Trie::Add();
    }
}
void dfs(int k){
    get_sz(k,0);
    get_rt(k,0,sz[k]);
    calc(rt,0);
    vis[rt]=1;
    for(int i=head[rt];i!=-1;i=edge[i].nex)
        if (!vis[edge[i].to])calc(edge[i].to,1);
    for(int i=head[rt];i!=-1;i=edge[i].nex)
        if (!vis[edge[i].to])dfs(edge[i].to);
}
int main(){
    for(int i=2;i<(N<<2);i++)
        if (lowbit(i>>1)==1)f[i]=0;
        else f[i]=((i>>1)/lowbit(i>>1)<<1);
    scanf("%d",&t);
    while (t--){
        scanf("%d",&n);
        E=0;
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        memset(ans,0,sizeof(ans));
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            a[i]--;
        }
        for(int i=1;i<n;i++){
            scanf("%d%d",&x,&y);
            add_edge(x,y);
            add_edge(y,x);
        }
        dfs(1);
        for(int i=1;i<n;i++)printf("%lld ",ans[i]);
        printf("%lld\n",ans[n]);
    }
    return 0;
}