Codeforces 1100F（离线 or 在线）

传送门

 

•参考资料

　　[1]:在线线性基

　　[2]:离线线性基

　　[3]:离线线性基

•题意

　　给你 n 个数，m 次询问；

　　每次询问给定一个区间 $l,r$，求 $a_{l \cdots r}$ 异或的最大值；

•线段树+线性基

　　参考了一下资料[1]，学会了如何将线性基和线段树结合；

　　虽然在此题中会 TLE，但是却学到了不少东西；

　　首先，在建树的时候，将叶节点上的值插入到线性基中；

　　在回溯的时候，通过 Merge 操作，将 pos 的儿子节点的线性基合并到 pos 的线性基上；

　　类似于常规线段树中的 pushUp 操作；

　　此算法可以用来做这道题：洛谷P4839

•Code(线段树TLE版本)

#include<bits/stdc++.h>
using namespace std;
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
const int maxn=5e5+50;
 
int n,q;
int a[maxn];
struct Seg
{
    int l,r;
    int a[25];
    int mid(){return l+((r-l)>>1);}
    void Insert(int x)
    {
        for(int i=20;i >= 0;--i)
        {
            if(x&(1<<i))
            {
                if(!a[i])
                {
                    a[i]=x;
                    return ;
                }
                x ^= a[i];
            }
        }
    }
    int Max()
    {
        int ans=0;
        for(int i=20;i >= 0;--i)
            ans=max(ans,ans^a[i]);
        return ans;
    }
}seg[maxn<<2];
 
Seg Marge(Seg a,Seg b)
{
    Seg tmp=b;
    for(int i=0;i <= 20;++i)
        if(a.a[i])
            tmp.Insert(a.a[i]);
    return tmp;
}
void buildSeg(int l,int r,int pos)
{
    seg[pos].l=l;
    seg[pos].r=r;
 
    if(l == r)
    {
        seg[pos].Insert(a[l]);
        return ;
    }
 
    int mid=l+((r-l)>>1);
    buildSeg(l,mid,ls(pos));
    buildSeg(mid+1,r,rs(pos));
 
    seg[pos]=Marge(seg[ls(pos)],seg[rs(pos)]);
    seg[pos].l=l;///此处要注意，因为Marge返回的结果未给l,r赋值
    seg[pos].r=r;
}
Seg Query(int l,int r,int pos)
{
    if(seg[pos].l == l && seg[pos].r == r)
        return seg[pos];
 
    int mid=seg[pos].mid();
 
    if(r <= mid)
        return Query(l,r,ls(pos));
    else if(l > mid)
        return Query(l,r,rs(pos));
    else
        return Marge(Query(l,mid,ls(pos)),Query(mid+1,r,rs(pos)));
}
void Solve()
{
    for(int i=1;i <= q;++i)
    {
        int l,r;
        scanf("%d%d",&l,&r);
 
        Seg ans=Query(l,r,1);
 
        printf("%d\n",ans.Max());
    }
}
int main()
{
//    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
        scanf("%d",a+i);
    buildSeg(1,n,1);
 
    scanf("%d",&q);
    Solve();
 
    return 0;
}

•离线线性基

　　学会了和线段树结合后，看了看正解 线性基+贪心，果然，看不懂；

　　放弃了这个解法，找了几篇离线线性基的做法（资料[2],[3]）；

　　大致做法是，将所有询问收集起来，并按照 r 升序排列；

　　边插入 a_i 边判断当前的 i 是否为当前询问的右端点；

　　插入的时候，记录两个数值 base[ i ] , p[ i ]，表示第 p[ i ] 个数 $a_{p_i}$ 在通过 Insert() 操作时，插入的时候插到了 base[ i ] 中；

　　每次插入第 i 个数 a_i 时，优先让高位的 1 用当前的位置来表示，这样可以保证高位的 1 对应的 base 值可以对最大值有贡献；

•Code(离线)

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+50;
 
int n,m;
int a[maxn];
struct Query
{
    int l,r;
    int pos;
    bool operator < (const Query &obj) const
    {
        return r < obj.r;
    }
}q[maxn];
int base[30];
int p[30];
int ans[maxn];
 
void Insert(int pos,int x)
{
    for(int i=20;i >= 0;--i)
    {
        if(x&(1<<i))
        {
            if(!base[i])
            {
                base[i]=x;
                p[i]=pos;
                return ;
            }
            else if(pos > p[i])///第i位的base[i]优先让p大的表示
            {
                swap(base[i],x);
                swap(p[i],pos);
            }
            x ^= base[i];
        }
    }
}
int Max(int k)
{
    int l=q[k].l;
    int r=q[k].r;
 
    int ans=0;
    ///查询时，保证p大的高位base优先考虑
    for(int i=20;i >= 0;--i)
        if(p[i] >= l && p[i] <= r)
            ans=max(ans,ans^base[i]);
    return ans;
}
void Solve()
{
    sort(q+1,q+m+1);
 
    int k=1;
    for(int i=1;i <= n;++i)
    {
        Insert(i,a[i]);

        while(i == q[k].r)
        {
            
            ans[q[k].pos]=Max(k);
            k++;
        }
    }
 
    for(int i=1;i <= m;++i)
        printf("%d\n",ans[i]);
 
    return ;
}
int main()
{
//    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
        scanf("%d",a+i);
 
    scanf("%d",&m);
    for(int i=1;i <= m;++i)
    {
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].pos=i;
    }
 
    Solve();
 
    return 0;
}

•在线线性基

　　学会了离线的，再看资料[1]的正解代码时，理解起来容易了不少；

•Code(在线)

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+50;

int n,q;
int a[maxn];
int base[maxn][30];
int p[maxn][30];

void Insert(int pos,int x,int k)
{
    for(int i=20;i >= 0;--i)
    {
        if(x&(1<<i))
        {
            if(!base[k][i])
            {
                base[k][i]=x;
                p[k][i]=pos;
            }
            else if(pos > p[k][i])
            {
                swap(pos,p[k][i]);
                swap(x,base[k][i]);
            }
            x ^= base[k][i];
        }
    }
}
int Max(int l,int r)
{
    int ans=0;
    for(int i=20;i >= 0;--i)
        if(p[r][i] >= l)
            ans=max(ans,ans^base[r][i]);
    return ans;
}
void Solve()
{
    for(int i=1;i <= n;++i)
    {
        memcpy(base[i],base[i-1],sizeof(base[i-1]));
        memcpy(p[i],p[i-1],sizeof(p[i-1]));

        Insert(i,a[i],i);
    }

    while(q--)
    {
        int l,r;
        scanf("%d%d",&l,&r);

        printf("%d\n",Max(l,r));
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
        scanf("%d",a+i);
    scanf("%d",&q);

    Solve();

    return 0;
}