小奇的仓库（树形DP)

「题目背景」

小奇采的矿实在太多了，它准备在喵星系建个矿石仓库。令它无语的是，喵星系的货运飞船引擎还停留在上元时代！

「问题描述」

喵星系有n个星球，星球以及星球间的航线形成一棵树。

从星球a到星球b要花费[dis(a,b) Xor M]秒。（dis（a,b）表示ab间的航线长度，Xor为位运算中的异或）

为了给仓库选址，小奇想知道，星球i（1<=i<=n）到其它所有星球花费的时间之和。

「输入格式」

第一行包含两个正整数n，M。
接下来n-1行，每行3个正整数a,b,c，表示a，b之间的航线长度为c。

「输出格式」

n行，每行一个整数，表示星球i到其它所有星球花费的时间之和。

「样例输入」

4 0

1 2 1

1 3 2

1 4 3

「样例输出」

6

8

10

12

「数据范围」

序号   N    M

 1    6    0

 2   100   5

 3  2000   9

 4  50000  0

 5  50000  0

 6  50000  1

 7  50000  6

 8  100000 10

 9  100000 13

 10 100000 15

保证答案不超过2*10^9

下面一段话是出题人神秘而不失优雅的题解

算法1：

不会写函数的小伙伴们，我们只需要写个floyd，就有10分啦！

算法2：

在算法1的基础上，我们对每条边处理一下xor，就有20分啦！

算法3：

简单的树形DP，或者你会nlogn的dij，处理完每个点到其它点的最短路后再加上xor，那么这样就有30分啦！

算法4：

第4、5个点无需xor，那么我们树形DP扫一个节点与其它所有节点的路径长度之和，可以合并信息，最终均摊O(1)，50分到手。

算法5：

第6个点xor 1，那么我们树形DP到一个点时记录有多少个0，多少个1，然后每当一条路径到2，那部分就再记录一个值，60分到手。

算法6：

如果你第6个点都过了，却没有满分，笨死啦！

一样的嘛，就是原来的“0”、“1”、大于等于2变成了0~16么~~

---

下面是自己的话：

既然是棵树，又要快速地求每个点的值，那一定是树形DP加上换根的操作啦~

但是异或m要怎么处理呢？可以观察数据规模，发现m最大最大也就15，换成二进制数也就是 1111，所以发现异或m最多只会对数字的后面4位造成影响（异或0甚至无法造成什么影响）

于是愉快地写出DP数组 f[i]和sz[i][0~15]

f表示此时以i为根的子树到i节点的距离之和（减去后缀后的和）

sz表示此时距离以j为后缀的共有几个

每一次向根节点方向转移时会加上一条边的长度，此时不同后缀距离的后缀会发生相应改变，然后更新父亲相应后缀的sz值。

然后f里统计的距离总和是抹掉所有后缀后的总和，即不考虑后缀的贡献。如有一个距离是 10111(2),抹去长度为2的后缀后就只剩下10100，然后将这个结果加到f数组里，到最后根节点统计最终答案时再考虑每个后缀的贡献，此时的sz数组就派上用场了（具体看代码）

还有一点，就是最后要把答案减去m，因为统计后缀贡献时，多加了自己到自己的距离（本来为0，xor m 后变成了m)。

代码如下

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>

 #define For(i,a,b) for(register int i=a;i<=b;++i)
 #define Re register
 #define Pn putchar('\n')
 #define inf 0x7f7f7f
 #define llg long long
 using namespace std;
 const int N=1e5+;
 int sz[N][];
 int head[N],nxt[N*],v[N*],cnt=;
 llg w[N*],z,fn[N],f[N];
 int n,m,x,y,ct,tot;

 inline void read(int &v){
     v=;
     char c=getchar();
     while(c<''||c>'')c=getchar();
     while(c>=''&&c<='')v=v*+c-'',c=getchar();
 }
 inline void read(llg &v){
     v=;
     char c=getchar();
     while(c<''||c>'')c=getchar();
     while(c>=''&&c<='')v=v*+c-'',c=getchar();
 }
 void write(llg x){
     if(x>)write(x/);
     int xx=x%;
     putchar(xx+'');
 }

 void add(int ux,int vx,llg wx){
     cnt++;
     nxt[cnt]=head[ux]; head[ux]=cnt; v[cnt]=vx; w[cnt]=wx;
     cnt++;
     nxt[cnt]=head[vx]; head[vx]=cnt; v[cnt]=ux; w[cnt]=wx;
 }

 void DFS1(int x,int fa){
     sz[x][]=;
     for(Re int i=head[x];i;i=nxt[i]){
         int vv=v[i];
         if(vv==fa)continue;
         DFS1(vv,x);
         f[x]+=f[vv];
         For(j,,tot){
             int Nsm=j+w[i];
             int Nst=Nsm & ct;
             sz[x][Nst]+=sz[vv][j];
             f[x]+=sz[vv][j]*(Nsm-Nst);
         }
     }
 }
 int Bsz[N][];
 void DFS2(int x,int fa){   //换根
     fn[x]=f[x];
     For(st,,tot){
         fn[x]+=(st^m)*sz[x][st];
     }
     For(st,,tot)Bsz[x][st]=sz[x][st];
     llg Bf=f[x];

     for(Re int i=head[x];i;i=nxt[i]){
         int vv=v[i];
         if(vv==fa)continue;

         int Nsm,Nst;

         For(st,,tot){
             Nsm =st+w[i];
             Nst=Nsm&ct;
             sz[x][Nst]-=sz[vv][st];
             f[x]-=sz[vv][st]*(Nsm-Nst);
         }

         f[vv]=f[x];
         For(st,,tot){
             Nsm=st+w[i];
             Nst=Nsm&ct;
             sz[vv][Nst]+=sz[x][st];
             f[vv]+=sz[x][st]*(Nsm-Nst);
         }

         DFS2(vv,x);

         f[x]=Bf;
         For(st,,tot)sz[x][st]=Bsz[x][st];
     }
 }

 int main(){
 //    freopen("warehouse.in","r",stdin);
 //    freopen("warehouse.out","w",stdout);
     read(n); read(m);

     if(m==)ct=,tot=;
     if(m==)ct=,tot=;
     if(m==)ct=,tot=;
     if(m==)ct=,tot=;
     if(m>=)ct=,tot=;  //简单粗暴的预处理 

     For(i,,n-){
         read(x); read(y); read(z);
         add(x,y,z);
     }
     DFS1(,);
     DFS2(,);
     For(i,,n){
          write(fn[i]-m); Pn;
     }
     return ;
 }