线性基学习

线性基

所谓基就是基底

线性基就可以理解为n个数异或（xor）的基底

题型

1，最大/最小异或和

2，第k大异或和

3，求所有异或值得和

性质

1，线性基的异或集合中不存在0（很容易证明：根据xor的性质即可）

2，线性基能相互异或得到原集合的所有相互异或得到的值（这也是线性基的优美之处）

3，线性基二进制最高位互不相同

4，如果线性基是满的，它的异或集合为[1,2n−1]

构造

对n个数，每个数字的二进制位，从高位到低位，扫到第i位时，若a[i]已在基里，则让x异或（xor）a[i]，否则将x加入基中，即a[i]=x即可，不难看出每个数要不就加入基中，要不然就被xor到0

for(int i=1;i<=n;i++) {    
 
    　　　　for(int j=62;j>=0;j--) {
 
        　　　　 if(!(a[i]>>j)) continue;//对线性基的这一位没有贡献           
 
        　　　　　 　if(!p[j]) { p[j]=a[i]; break; }//选入线性基中                   
 
        　　　　　　 a[i]^=p[j];
 
        　　　　 }
 
    　　　}

合并

直接暴力合并即可，就像插入一样即可

查询

1，查询任意一个值，直接将这个数的二进制位的1和线性基进行xor，如果x（这个数）变为0，则可以

2，查询max，从高位到低位扫描线性基，如果异或后可以使得答案变大，就异或到答案中去

long long query_max()
{
    long long ret=0;
    for (int i=60;i>=0;i--)
        if ((ret^d[i])>ret)
            ret^=d[i];
    return ret;
}

3，查询min，最小值即为最低位上的线性基（前提是没有0）

long long query_min()
{
    for (int i=0;i<=60;i++)
        if (d[i])
            return d[i];
    return 0;
}

4，第k小

根据性质3。 
我们要将线性基改造成每一位相互独立。 
具体操作就是如果i<j，aj的第i位是1，就将aj异或上ai。 
经过一系列操作之后，对于二进制的某一位i。只有ai的这一位是1，其他都是0。 
所以查询的时候将k二进制拆分，对于1的位，就异或上对应的线性基。 
最终得出的答案就是k小值。

模板

struct L_B{
    long long d[61],p[61];
    int cnt;
    L_B()
    {
        memset(d,0,sizeof(d));
        memset(p,0,sizeof(p));
        cnt=0;
    }
    bool insert(long long val)
    {
        for (int i=60;i>=0;i--)
            if (val&(1LL<<i))
            {
                if (!d[i])
                {
                    d[i]=val;
                    break;
                }
                val^=d[i];
            }
        return val>0;
    }
    long long query_max()
    {
        long long ret=0;
        for (int i=60;i>=0;i--)
            if ((ret^d[i])>ret)
                ret^=d[i];
        return ret;
    }
    long long query_min()
    {
        for (int i=0;i<=60;i++)
            if (d[i])
                return d[i];
        return 0;
    }
    void rebuild()
    {
        for (int i=60;i>=0;i--)
            for (int j=i-1;j>=0;j--)
                if (d[i]&(1LL<<j))
                    d[i]^=d[j];
        for (int i=0;i<=60;i++)
            if (d[i])
                p[cnt++]=d[i];
    }
    long long kthquery(long long k)
    {
        int ret=0;
        if (k>=(1LL<<cnt))
            return -1;
        for (int i=60;i>=0;i--)
            if (k&(1LL<<i))
                ret^=p[i];
        return ret;
    }
}
L_B merge(const L_B &n1,const L_B &n2)
{
    L_B ret=n1;
    for (int i=60;i>=0;i--)
        if (n2.d[i])
            ret.insert(n1.d[i]);
    return ret;
}