Magic Number LCA求路径点集的并

题意：给n个数(n<=5000)第i个数由i个二进制串组成。输入的税后会告诉你这个二进制串S里哪些位置为1(1的数量<100w)，每个数的01串是从左到右，左边为低位。

你可以根据n个数(题目中的a数组) 得到b数组。规则如下：

PS：可以看出b[i]第i位一定为1 i+1 ~ n位一定为0 若b[i]的第j位为1，则满足条件的b[k]第j位都为1

再回给你一个询问数q，和另一个01串T(1的数量<100w)，输入会告诉哪些位置是1，将T分为q段，每一段长度为c[i]

让你得到d[i],每次输出d[i]中有多少个1.

d[i]的规则如下：

这么长的题面真是.......

题解：一个LCA好题，首先我们想如何快速得到b数组，我们发现b[i]的状态取决于所有能更新他的b[j],b[i]的第i位为1，往后假如b[k]的第i为也为1，那么更新b[k]的数第i位都得为1。然后我们神奇的发现，把b[I]作一个节点表示第i位为1，b[i]的状态就是从i点到根的路径上所有点(路径上有j号点，则b[I]的第j位为1)。 这样建树是正确的，因为i是第1个i号位置为1的节点，要想i号位置为1，那么这个点一定在i号点的子树里(&操作，每个用于更新的点第i位都得是1)

所以建树的时候要寻找众多更新状态节点的LCA。

得到b[i]的状态之后，问题就变为了，多个点到根节点的节点的并集，这个问题直接把每个集合里的点按dfs序排序，然后减去相邻点的LCA就好了。因为求并集的时候最难的是去重，若几个点在同一子树下，在乱序的情况下就很难去重了，然而如果按dfs序更新的话，可以保证加入点一直在当前统计了的点的集合的外面。看不懂的话就自己YY吧。。。。

#include <algorithm>
#include <vector>
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std ;
#define clr( a , x ) memset ( a , x , sizeof a )
int n , m , q ;
#define deg 15
#define maxn 5100
#define maxm 1100000
int a[maxn],b[maxn],c[maxm] ;
int fa[maxn][20],dep[maxn] ;
int dfn[maxn],cnt;
vector<int>g[maxn] ;
int read()
{
    char c;int tmp;
    while (c=getchar(),c<'0'||c>'9');
    tmp=c-'0';
    while(c=getchar(),c>='0'&&c<='9')
        tmp = tmp * 10 + c - '0' ;
    return tmp;
}
int lca(int u,int v)
{
    if(dep[u]<dep[v])  swap(u,v);
    int du,dv,tu=u,tv=v;
    du=dep[u];
    dv=dep[v];
    for(int i=deg-1;i>=0;i--)
        if(dep[fa[tu][i]]>=dep[tv])
        {
            tu=fa[tu][i];
        }
    if(tu==tv) return tu;

    for(int i=deg-1;i>=0;i--)
    {
        if(fa[tu][i]==fa[tv][i]) continue;
        tv=fa[tv][i];
        tu=fa[tu][i];
    }
    return fa[tu][0];
}

void dfs(int x)
{
    cnt++;
    dfn[x]=cnt;
    for ( int i=0;i<g[x].size();i++)
        dfs(g[x][i]);
}
bool cmp(int aa ,int bb)
{
    return dfn[aa] < dfn[bb] ;
}


void solve ()
{
    clr(fa,-1) ;
    cnt=0;
    scanf("%d%d",&n,&m);
    for(int i=0;i<=n;i++)
        g[i].clear();
    for(int i=1;i<=m;i++) a[i]=read()+1;

    sort(a+1,a+m+1) ;
    int j = 1 ;
    for ( int i = 1 ; i <= n ; ++ i )
    {
        int now=-1;
        int ll=i*(i-1)/2+1;
        int rr=i*(i+1)/2;
        for(;j<=m && a[j]<=rr;j++ )
        {
            int t = a[j]-ll+1;
            if (t>=i) continue ;
            if (now==-1)now=t;
            else now=lca(now,t);
        }
        if (now==-1) now=0;
        dep[i]=dep[now]+1;
        fa[i][0]=now;
        g[now].push_back(i);
        for(int j=1;j<deg;j++) fa[i][j] = fa[fa[i][j-1]][j-1];
    }
    dfs(0);
    scanf ("%d%d",&q,&m);
    for(int i=1;i<=q;i++) b[i]=read();
    for(int i=1;i<=m;i++) c[i]=read()+1;

    sort (c+1,c+m+1) ;

    int tot = 0 ;
    j = 1 ;
    for(int i=1;i<=q;i++)
    {
        int ll = tot + 1 ;
        int rr = tot + b[i] , n1 = 0 ;
        for( ;j<=m && c[j]<=rr;j++ )
        {
            int t = c[j] - ll + 1 ;
            if ( t <= n )
            {
                n1++;
                a[n1] = t ;
            }
        }
        sort(a+1,a+n1+1,cmp);
        int ans = 0 ;
        for (int k=1;k<=n1;k++)
        {
            ans += dep[a[k]] ;
            if(k-1)ans -= dep[lca(a[k-1],a[k])] ;
        }
        printf ("%d\n",ans) ;
        tot += b[i] ;
    }
}

int main()
{
    int cas;
    scanf("%d",&cas);
    for(int i=1;i<=cas;i++)
    {
        printf("Case #%d:\n",i);
        solve();
    }
    return 0 ;
}