CSU_1414 Query On a Tree BFS序+DFS时间戳进行预处理

2014 csu校赛 I 题，比赛的时候拿着他看了几个小时愣是没弄出好的方法，我们也想过统计出每个root的节点总数，然后减去离它d层的子节点的数目，即为答案。但是因为树的存储是无序的，所以每次为了找到子节点还是需要搜索，这肯定是承受不了的。

事实上，这个思路大体是对的，只是需要进行预处理，使得在找离它为d层的子节点能尽量节约时间，此外，如果找到了子节点挨个去减，也是很费时的，因为这些子节点必定处在同一层，他们的bfs序是连续的，故比较容易想到用前缀和来快速求得某一层的所有儿子的数目。

我们看这样的树

因此我们如果能把每个root的dfs时间戳的最小值和最大值给记录一下，再求出bfs序，则，对于某一层的所有节点，只要是时间戳在该root的最小值和最大值范围内，则必定是我们要求得孩子节点。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #define N 100010
 using namespace std;
 vector <int> deep_num[N];
 int u[N],v[N],nt[N],ft[N],cnt,dfs_clock;
 int last[N][],max_deep[N],tot[N],deep[N],sum[N];
 void add(int a,int b){
     u[cnt]=a;
     v[cnt]=b;
     nt[cnt]=ft[a];
     ft[a]=cnt++;
 }
 void init(int num)
 {
     cnt=;
     dfs_clock=;
     sum[]=;

     for (int i=;i<=num;i++){
         ft[i]=-;
         nt[i]=;
         u[i]=v[i]=;
         deep_num[i].clear();
         deep_num[i].push_back(); //先给每个层预先加一个0，方便之后处理
     }
 }
 void dfs(int u,int d)
 {
     last[u][]=++dfs_clock;
     deep_num[d].push_back(u);//这里直接把节点存入相应的层，省去了BFS，直接达到了计算BFS序的作用
     tot[u]=;
     deep[u]=d;
     max_deep[u]=d;
     for (int w=ft[u];w>=;w=nt[w]){
         int x=v[w];
         dfs(x,d+);
         tot[u]+=tot[x];//计算root节点下的节点总数
         max_deep[u]=max(max_deep[u],max_deep[x]);//记录该root最大层有多深
     }
     last[u][]=dfs_clock;
     if (deep_num[deep[u]].size()>)
         sum[u]=sum[deep_num[deep[u]][deep_num[deep[u]].size()-]]+tot[u];//因为没有进行BFS，所以计算前缀和要稍微麻烦一点，根据存贮好的每一层的节点来计算
     else
         sum[u]=sum[deep_num[deep[u]-][deep_num[deep[u]-].size()-]]+tot[u];
 }
 int query(int x,int d)
 {
     if (max_deep[x]<=deep[x]+d-)//如果该root没有那一层的孩子，则可以直接返回，因为肯定不需要减孩子了
         return tot[x];
     int val=last[x][];
     int ret=tot[x];
     int nd=deep[x]+d;
     int L=,R=deep_num[nd].size()-,mid;
     int a,b;
     while (L<R)//
     {

         mid=(L+R)/;
         //cout<<L<<" "<<R<<" "<<mid<<endl;
         int nx=deep_num[nd][mid];
         if (last[nx][]>=val) R=mid;
         else L=mid+;
         //cout<<nx<<" !!! "<<endl;
     }
     //cout<<"pass"<<endl;
     a=deep_num[nd][L-];算出左边界，因为要算前缀和，所以L-1，这样前面的push 0在这里也起到作用了
     val=last[x][];
     L=,R=deep_num[nd].size()-;
     while (L<R)
     {
         mid=R-(R-L)/;
         int nx=deep_num[nd][mid];
         if (last[nx][]<=val) L=mid;
         else R=mid-;
        // cout<<nx<<" ~~ "<<endl;
     }
     b=deep_num[nd][R];
     //cout<<a<<" ab "<<b<<endl;
     //cout<<sum[a]<<" sum "<<sum[b]<<endl;
     ret-=sum[b]-sum[a]; //减去前缀和，其实还有个细节就是因为刚刚已经判断了，所以一定有孩子在这一层，所以这样减一定是合理的，不会出现没孩子也减掉的情况
     return ret;

 }
 int main()
 {
     int t,n,m,x,d;
     scanf("%d",&t);
     while (t--){
         scanf("%d",&n);
         init(n);
         for (int i=;i<=n;i++){
             int tmp;
             scanf("%d",&tmp);
             add(tmp,i);
         }
         dfs(,);
         scanf("%d",&m);
         while (m--){
             scanf("%d%d",&x,&d);
             int ans=query(x,d);
             printf("%d\n",ans);
         }
     }
     return ;
 }