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

 int n,q;
 int a[maxn];
 struct Seg
 {
     int l,r;
     int a[];
     int mid(){return l+((r-l)>>);}
     void Insert(int x)
     {
         for(int i=;i >= ;--i)
         {
             if(x&(<<i))
             {
                 if(!a[i])
                 {
                     a[i]=x;
                     return ;
                 }
                 x ^= a[i];
             }
         }
     }
     int Max()
     {
         int ans=;
         for(int i=;i >= ;--i)
             ans=max(ans,ans^a[i]);
         return ans;
     }
 }seg[maxn<<];

 Seg Marge(Seg a,Seg b)
 {
     Seg tmp=b;
     for(int i=;i <= ;++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)>>);
     buildSeg(l,mid,ls(pos));
     buildSeg(mid+,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+,r,rs(pos)));
 }
 void Solve()
 {
     for(int i=;i <= q;++i)
     {
         int l,r;
         scanf("%d%d",&l,&r);

         Seg ans=Query(l,r,);

         printf("%d\n",ans.Max());
     }
 }
 int main()
 {
 //    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
     scanf("%d",&n);
     for(int i=;i <= n;++i)
         scanf("%d",a+i);
     buildSeg(,n,);

     scanf("%d",&q);
     Solve();

     return ;
 }

•离线线性基

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

　　放弃了这个解法，找了几篇离线线性基的做法（资料[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+;

 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[];
 int p[];
 int ans[maxn];

 void Insert(int pos,int x)
 {
     for(int i=;i >= ;--i)
     {
         if(x&(<<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=;
     ///查询时，保证p大的高位base优先考虑
     for(int i=;i >= ;--i)
         if(p[i] >= l && p[i] <= r)
             ans=max(ans,ans^base[i]);
     return ans;
 }
 void Solve()
 {
     sort(q+,q+m+);

     int k=;
     for(int i=;i <= n;++i)
     {
         Insert(i,a[i]);

         while(i == q[k].r)
         {

             ans[q[k].pos]=Max(k);
             k++;
         }
     }

     for(int i=;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=;i <= n;++i)
         scanf("%d",a+i);

     scanf("%d",&m);
     for(int i=;i <= m;++i)
     {
         scanf("%d%d",&q[i].l,&q[i].r);
         q[i].pos=i;
     }

     Solve();

     return ;
 }

•在线线性基

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

•Code(在线)

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

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

 void Insert(int pos,int x,int k)
 {
     for(int i=;i >= ;--i)
     {
         if(x&(<<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=;
     for(int i=;i >= ;--i)
         if(p[r][i] >= l)
             ans=max(ans,ans^base[r][i]);
     return ans;
 }
 void Solve()
 {
     for(int i=;i <= n;++i)
     {
         memcpy(base[i],base[i-],sizeof(base[i-]));
         memcpy(p[i],p[i-],sizeof(p[i-]));

         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=;i <= n;++i)
         scanf("%d",a+i);
     scanf("%d",&q);

     Solve();

     return ;
 }