線性基講解

定義

設數集T的值域范圍為[1,2^n−1]。
T的線性基是T的一個子集A={a1,a2,a3,...,an}。
A中元素互相xor所形成的異或集合，等價於原數集T的元素互相xor形成的異或集合。
可以理解為將原數集進行了壓縮。

性質
1.設線性基的異或集合中不存在0。
2.線性基的異或集合中每個元素的異或方案唯一，其實這個跟性質1是等價的。
3.線性基二進制最高位互不相同。
4.如果線性基是滿的，它的異或集合為[1,2^n−1]。
5.線性基中元素互相異或，異或集合不變。

維護
插入
如果向線性基中插入數x，從高位到低位掃描它為1的二進制位。
掃描到第i時，如果ai不存在，就令ai=x否則x=x⊗ai。
x的結局是，要么被扔進線性基，要么經過一系列操作過后，變成了0。

bool insert(long long val)
{
    for (int i=60;i>=0;i--)
        if (val&(1LL<<i))
        {
            if (!a[i])
            {
                a[i]=val;
                break;
            }
            val^=a[i];
        }
    return val>0;
}

　　

合並

將一個線性基暴力插入另一個線性基即可。

L_B merge(const L_B &n1,const L_B &n2)
{
    L_B ret=n1;
    for (int i=0;i<=60;i++)
        if (n2.d[i])
            ret.insert(n2.d[i]);
    return ret;
}

 

查詢

存在性

如果要查詢x是否存於異或集合中。 
從高位到低位掃描x的為1的二進制位。 
掃描到第i位的時候x=x⊗ai
如果中途x變為了0，那么表示x存於線性基的異或集合中。

最大值

從高位到低位掃描線性基。 
如果異或后可以使得答案變大，就異或到答案中去。

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;
}

　

k小值
根據性質3。
我們要將線性基改造成每一位相互獨立。
具體操作就是如果i<j，aj的第i位是1，就將aj異或上ai。
經過一系列操作之后，對於二進制的某一位i。只有ai的這一位是1，其他都是0。
所以查詢的時候將k二進制拆分，對於1的位，就異或上對應的線性基。
最終得出的答案就是k小值。

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;
}

模板

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;
}