洛谷 P3292 [SCOI2016]幸运数字 线性基+倍增

题目描述

A 国共有 n 座城市，这些城市由 n-1 条道路相连，使得任意两座城市可以互达，且路径唯一。每座城市都有一个幸运数字，以纪念碑的形式矗立在这座城市的正中心，作为城市的象征。

一些旅行者希望游览 A 国。旅行者计划乘飞机降落在 x 号城市，沿着 x 号城市到 y 号城市之间那条唯一的路径游览，最终从 y 城市起飞离开 A 国。在经过每一座城市时，游览者就会有机会与这座城市的幸运数字拍照，从而将这份幸运保存到自己身上。然而，幸运是不能简单叠加的，这一点游览者也十分清楚。他们迷信着幸运数字是以异或的方式保留在自己身上的。

例如，游览者拍了 3 张照片，幸运值分别是 5，7，11，那么最终保留在自己身上的幸运值就是 9（5 xor 7 xor 11）。

有些聪明的游览者发现，只要选择性地进行拍照，便能获得更大的幸运值。例如在上述三个幸运值中，只选择 5 和 11 ，可以保留的幸运值为 14 。现在，一些游览者找到了聪明的你，希望你帮他们计算出在他们的行程安排中可以保留的最大幸运值是多少。

输入输出格式

输入格式：
第一行包含 2 个正整数 n ，q，分别表示城市的数量和旅行者数量。

第二行包含 n 个非负整数，其中第 i 个整数 Gi 表示 i 号城市的幸运值。

随后 n-1 行，每行包含两个正整数 x ，y，表示 x 号城市和 y 号城市之间有一条道路相连。

随后 q 行，每行包含两个正整数 x ，y，表示这名旅行者的旅行计划是从 x 号城市到 y 号城市。N<=20000,Q<=200000,Gi<=2^60

输出格式：
输出需要包含 q 行，每行包含 1 个非负整数，表示这名旅行者可以保留的最大幸运值。

输入输出样例

输入样例#1：
4 2
11 5 7 9
1 2
1 3
1 4
2 3
1 4
输出样例#1：
14
11

分析：
求集合的最大异或和，可以使用线性基，也就是求异或方程组的对角线矩阵，具体来说就是通过两两异或，使得每一个主元列只有一个数的该位是$1$，后面的不管。可以知道这样的一组线性基可以表示任意原来所有数可以表示的数，而且化成这样后，答案就是所有值的异或和，因为每一个高位的优先级都比低位高，因为一共只有$61$为二进制数，所以线性基不超过$61$个。然后直接用倍增法维护某个点往上$2^j$的线性基，然后就是合并答案。求解时可以使用$lca$往下和$x$和$y$往上的区间合并，类似于$rmq$，多余的数不影响解。

代码：

#include <iostream>
#include <cmath>
#include <cstdio>
#define LL long long

const int maxn=2e4+7;
const int maxp=61;

using namespace std;

struct node{
    LL num[maxp+7];
}t[maxn][15];

struct edge{
    int y,next;
}g[maxn*2];

int n,m,x,y,cnt;
LL bit[maxp+7];
LL a[maxn];
int f[maxn][15],ls[maxn],dep[maxn];

void add(int x,int y)
{
    g[++cnt]=(edge){y,ls[x]};
    ls[x]=cnt;
}

void ins(node &x,LL y)
{   
    if (y==0) return;
    int c=0;    
    for (int i=1;i<=maxp;i++)
    {
        if (y&bit[maxp-i])
        {
            if ((!x.num[i]) && (!c)) c=i;
            y^=x.num[i];
        }
    }
    x.num[c]=y;
    for (int i=1;i<=maxp;i++)
    {
        if (i==c) continue;
        if (x.num[i]&bit[maxp-c]) x.num[i]^=x.num[c];
    }
}

void dfs(int x,int fa)
{
    f[x][0]=fa;
    ins(t[x][0],a[x]);
    for (int i=ls[x];i>0;i=g[i].next)
    {
        int y=g[i].y;
        if (y==fa) continue;
        dep[y]=dep[x]+1;
        dfs(y,x);
    }
}

node merge(node x,node y)
{
    node z=x;   
    for (int i=1;i<=maxp;i++) ins(z,y.num[i]);    
    return z;
}

int up(int x,int d)
{
    int k=14,t=1<<k;
    while (d)
    {
        if (d>=t) x=f[x][k],d-=t;
        t/=2; k--;
    }
    return x;
}

int lca(int x,int y)
{
    if (dep[x]>dep[y]) swap(x,y);
    int d=dep[y]-dep[x];
    y=up(y,d);
    if (x==y) return x;
    int k=14;
    while (k>=0)
    {
        if (f[x][k]!=f[y][k])
        {
            x=f[x][k];
            y=f[y][k];
        }
        k--;
    }
    return f[x][0];
}

int main()
{   
    bit[0]=1;
    for (int i=1;i<=maxp;i++) bit[i]=bit[i-1]*2;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++) scanf("%lld",&a[i]);
    for (int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }   

    dfs(1,0);               
    for (int j=1;j<=14;j++)
    {
        for (int i=1;i<=n;i++)
        {
            f[i][j]=f[f[i][j-1]][j-1];
            t[i][j]=merge(t[i][j-1],t[f[i][j-1]][j-1]);
        }
    }       
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        int d=lca(x,y);
        int dep1=(dep[x]-dep[d]+1);
        int dep2=(dep[y]-dep[d]+1);
        int log1=trunc(log(dep1+0.5)/log(2));
        int log2=trunc(log(dep2+0.5)/log(2));       
        node q=merge(t[x][log1],t[y][log2]);
        q=merge(q,t[up(x,dep1-(1<<log1))][log1]);
        q=merge(q,t[up(y,dep2-(1<<log2))][log2]);
        LL ans=0;
        for (int i=1;i<=maxp;i++)
        {
            if (ans^q.num[i]>ans) ans^=q.num[i];
        }
        printf("%lld\n",ans);
    }
}