【BZOJ4568】幸运数字，树链剖分/倍增+维护线性基

Time:2016.09.06
Author:xiaoyimi
转载注明出处谢谢

---

传送门

思路：
对于两个线性基数组a,b,直接向b中加a的元素进行线性基合并就可以了
复杂度$O(P^2)$其中P是线性基的个数，对于这道题来说P最大是60
也就是说对于询问(x,y)，我们只要求出x->y路径上的线性基就可以了
暴力求是$O(QnP^2)$
我们考虑路径问题时，一般使用的是树链剖分
考虑链剖+线段树节点维护线性基
复杂度……总之很大，无论是空间还是时间
好像是$O(nlognP^2+Qlog^2nP^2)$
但是这个东西是不带修改，所以我们可以进化成ST表来维护它，这样每次链剖出的一段重链，查询就是$O(1)$的了
复杂度是
$O(nlognP^2+QlognP^2)$
因为BZOJ是总时限所以可过……

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#define M 20003
#define LL long long 
using namespace std;
int n,q,tot,cnt;
int first[M],top[M],dep[M],siz[M],son[M],fa[M],L[M],pre[M];
LL ST[M][15][63],t[63],lb[M];
struct edge{
    int v,next;
}e[M<<1];
int in()
{
    int t=0;char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9') t=(t<<1)+(t<<3)+ch-48,ch=getchar();
    return t;
}
LL LL_in()
{
    LL t=0;char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9') t=(t<<1)+(t<<3)+ch-48,ch=getchar();
    return t;
}
void add(int x,int y)
{
    e[++tot]=(edge){y,first[x]};first[x]=tot;
    e[++tot]=(edge){x,first[y]};first[y]=tot;
}
void dfs1(int x)
{
    siz[x]=1;
    for (int i=first[x];i;i=e[i].next)
        if (fa[x]!=e[i].v)
            fa[e[i].v]=x,
            dep[e[i].v]=dep[x]+1,
            dfs1(e[i].v),
            siz[x]+=siz[e[i].v],
            son[x]=(siz[son[x]]>siz[e[i].v]?son[x]:e[i].v); 
}
void dfs2(int x,int tp)
{
    L[x]=++cnt;
    pre[cnt]=x;
    top[x]=tp;
    if (son[x]) dfs2(son[x],tp);
    else return;
    for (int i=first[x];i;i=e[i].next)
        if (son[x]!=e[i].v&&fa[x]!=e[i].v) dfs2(e[i].v,e[i].v);
}
void unions(LL a[],LL c[])
{
    for (int i=0;i<=60;++i) t[i]=a[i];
    for (int i=0;i<=60;++i)
        for (int j=60;j>=0;--j)
        {
            if (!t[i]) break; 
            if (t[i]>>j&1)
                if (!c[j])
                {
                    c[j]=t[i];
                    break;
                }
                else t[i]^=c[j];
        }
}
main()
{
    n=in();q=in();
    for (int i=1;i<=n;++i) lb[i]=LL_in();
    for (int i=1;i<n;++i) add(in(),in());
    dfs1(1);
    dfs2(1,1);
    for (int i=1;i<=n;++i)
        for (int j=60;j>=0;--j)
            if (lb[i]>>j&1)
                {ST[L[i]][0][j]=lb[i];break;}
    for (int i=1;1<<i<=n;++i)
        for (int j=1;(1<<i)+j-1<=n;++j)
            unions(ST[j][i-1],ST[j][i]),
            unions(ST[j+(1<<i-1)][i-1],ST[j][i]);
    LL ans;int p;
    for (int l,r;q;--q)
    {
        l=in();r=in();ans=0;
        memset(lb,0,sizeof(lb));
        for(;top[l]!=top[r];l=fa[top[l]])
        {
            if (dep[top[l]]<dep[top[r]]) swap(l,r);
            p=log2(L[l]-L[top[l]]+1);
            unions(ST[L[top[l]]][p],lb);
            unions(ST[L[l]-(1<<p)+1][p],lb);
        }
        if (dep[l]>dep[r]) swap(l,r);
        p=log2(L[r]-L[l]+1);
        unions(ST[L[l]][p],lb);
        unions(ST[L[r]-(1<<p)+1][p],lb);
        for (int i=60;i>=0;--i)
             if (!(ans>>i&1)) ans^=lb[i];
        printf("%lld\n",ans);
    }
}

链剖带一个log，终究是比较慢的
所以在ST表的基础上再进行考虑倍增思想
如果我们直接维护的是任意节点到它2^i的祖先那里的线性基呢？
考虑询问(x,y)，找到LCA
这样的话每次询问我们只用合并4个线性基就可以了
只不过为了配合ST表的查询，我们需要加一个函数F(x,y)来查找节点x往上走深度为y的节点是谁
原先的链剖由于加上了dfs序，所以不用这么麻烦……
复杂度$O(nlognP^2+QP^2)$

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#define M 20003
#define LL long long
using namespace std;
int n,q,tot,cnt;
int first[M],fa[M][15],dep[M];
LL ST[M][15][62],t[62],lb[62],ans;
struct edge{
    int v,next;
}e[M<<1];
int in()
{
    int t=0;char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9') t=(t<<1)+(t<<3)+ch-48,ch=getchar();
    return t;
}
LL LL_in()
{
    LL t=0;char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9') t=(t<<1)+(t<<3)+ch-48,ch=getchar();
    return t;
}
void add(int x,int y)
{
    e[++tot]=(edge){y,first[x]};first[x]=tot;
    e[++tot]=(edge){x,first[y]};first[y]=tot;
}
void unions(LL a[],LL c[])
{
    for (int i=0;i<=60;++i) t[i]=a[i];
    for (int i=0;i<=60;++i)
        for (int j=60;j>=0;--j)
        {
            if (!t[i]) break;
            if (t[i]>>j&1)
                if (!c[j])
                {
                    c[j]=t[i];
                    break;
                }
                else t[i]^=c[j];
        }
}
void dfs(int x)
{
    for (int i=1;dep[x]-(1<<i)>0;++i)
        fa[x][i]=fa[fa[x][i-1]][i-1];
    for (int i=first[x];i;i=e[i].next)
        if (e[i].v!=fa[x][0])
            dep[e[i].v]=dep[x]+1,
            fa[e[i].v][0]=x,
            dfs(e[i].v);
}
int LCA(int x,int y)
{
    if (dep[x]<dep[y]) swap(x,y);
    for (int i=14;i>=0;--i)
        if (fa[x][i]&&dep[fa[x][i]]>dep[y])
            x=fa[x][i];
    if (dep[x]>dep[y])x=fa[x][0];
    if (x==y) return x;
    for (int i=14;i>=0;--i)
        if (fa[x][i]&&fa[y][i]&&fa[x][i]!=fa[y][i])
            x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
int cal(int x,int goal)
{
    if (dep[x]==goal) return x;
    for (int i=14;i>=0;--i)
        if (fa[x][i]&&dep[fa[x][i]]>goal)
            x=fa[x][i];
    return fa[x][0];
}
main()
{
    n=in();q=in();
    for (int i=1;i<=n;++i)
    {
        LL x=LL_in();
        for (int j=60;j>=0;--j)
            if (x>>j&1)
                {ST[i][0][j]=x;break;}
    }
    for (int i=1;i<n;++i) add(in(),in());
    dep[1]=1;dfs(1);
    for (int i=1;1<<i<=n;++i)
        for (int j=1;j<=n;++j)
            if (dep[j]-(1<<i)>=0)
                unions(ST[j][i-1],ST[j][i]),
                unions(ST[cal(j,dep[j]-(1<<i-1))][i-1],ST[j][i]);
    for (int x,y,z,p1,p2;q;--q)
    {
        memset(lb,0,sizeof(lb));
        x=in();y=in();ans=0;
        z=LCA(x,y);
        p1=log2(dep[x]-dep[z]+1);
        unions(ST[x][p1],lb);
        unions(ST[cal(x,dep[z]+(1<<p1)-1)][p1],lb);
        p2=log2(dep[y]-dep[z]+1);
        unions(ST[y][p2],lb);
        unions(ST[cal(y,dep[z]+(1<<p2)-1)][p2],lb);
        for (int i=60;i>=0;--i)
            if (!(ans>>i&1)) ans^=lb[i];
        printf("%lld\n",ans);
    }
}

重要的优化是

这优化不加你就等着TLE吧