线性基求交（线段树）--牛客第四场（xor）

题意：

给你n个基，q个询问，每个询问问你能不能 l~r 的所有基都能表示 x 。

思路：

建一颗线性基的线段树，up就是求交的过程，按照线段树区间查询的方法进行check就可以了。

#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#include <cstdio>//sprintf islower isupper
#include <cstdlib>//malloc  exit strcat itoa system("cls")
#include <iostream>//pair
#include <fstream>
#include <bitset>
//#include <map>
//#include<unordered_map>
#include <vector>
#include <stack>
#include <set>
#include <string.h>//strstr substr
#include <string>
#include <time.h>//srand(((unsigned)time(NULL))); Seed n=rand()%10 - 0~9;
#include <cmath>
#include <deque>
#include <queue>//priority_queue<int, vector<int>, greater<int> > q;//less
#include <vector>//emplace_back
//#include <math.h>
//#include <windows.h>//reverse(a,a+len);// ~ ! ~ ! floor
#include <algorithm>//sort + unique : sz=unique(b+1,b+n+1)-(b+1);+nth_element(first, nth, last, compare)
using namespace std;//next_permutation(a+1,a+1+n);//prev_permutation
#define fo(a,b,c) for(register int a=b;a<=c;++a)
#define fr(a,b,c) for(register int a=b;a>=c;--a)
#define mem(a,b) memset(a,b,sizeof(a))
#define pr printf
#define sc scanf
void swapp(int &a,int &b);
double fabss(double a);
int maxx(int a,int b);
int minn(int a,int b);
int Del_bit_1(int n);
int lowbit(int n);
int abss(int a);
//const long long INF=(1LL<<60);
const double E=2.718281828;
const double PI=acos(-1.0);
const int inf=(1<<29);
const double ESP=1e-9;
const int mod=(int)1e9+7;
const int N=(int)1e6+10;
 
struct node
{
    long long base[35];
 
    void Init()
    {
        for(int i=0;i<35;++i)
            base[i]=0;
    }
 
    bool check(long long x)
    {
        for(int i=31;i>=0;--i)
        {
            if(x&(1LL<<i))
            {
                if(!base[i])return 0;
                else x^=base[i];
            }
        }
        return 1;
    }
 
    void Insert(long long x)
    {
        for(int i=31;i>=0;--i)
        {
            if(x>>i&1)
            {
                if(base[i])
                    x^=base[i];
                else
                {
                    base[i]=x;
                    break;
                }
            }
        }
    }
}BASE[N<<2],temp,v;
 
void merge(const node &a,node &b,node &ans)
{
    temp=v=a;
    fo(i,0,31)
    {
        if(b.base[i])
        {
            long long x=b.base[i],now=0;
            int g=0;
            for(int j=31;j>=0;j--)
            {
                if(x>>j&1)
                {
                    if(!temp.base[j])
                    {
                        g=1;
                        temp.base[j]=x;
                        v.base[j]=now;
                        break;
                    }
                    x^=temp.base[j];now^=v.base[j];
                }
            }
            if(!g)
                ans.Insert(now);
        }
    }
}
 
void up(int rt)
{
    merge(BASE[rt<<1],BASE[rt<<1|1],BASE[rt]);
}
void Build(int l,int r,int rt)
{
    if(l==r)
    {
        int sz;
        long long x;
        sc("%d",&sz);
        fo(i,1,sz)
        {
            sc("%lld",&x);
            BASE[rt].Insert(x);
        }
        return;
    }
    int mid=(l+r)>>1;
 
    Build(l,mid,rt<<1);
    Build(mid+1,r,rt<<1|1);
    up(rt);
}
bool Query(int L,int R,long long V,int l,int r,int rt)
{
    if(L<=l&&r<=R)
        return BASE[rt].check(V);
    int mid=(l+r)>>1;
 
    if(L<=mid&&!Query(L,R,V,l,mid,rt<<1))
        return 0;
    if(R>mid&&!Query(L,R,V,mid+1,r,rt<<1|1))
        return 0;
    return 1;
}
 
int main()
{
    int n,m;
    sc("%d%d",&n,&m);
 
    Build(1,n,1);
    fo(i,1,m)
    {
        int l,r;
        long long x;
        sc("%d%d%lld",&l,&r,&x);
        if(Query(l,r,x,1,n,1))
            pr("YES
");
        else
            pr("NO
");
    }
    return 0;
}
 
/**************************************************************************************/
 
int maxx(int a,int b)
{
    return a>b?a:b;
}
 
void swapp(int &a,int &b)
{
    a^=b^=a^=b;
}
 
int lowbit(int n)
{
    return n&(-n);
}
 
int Del_bit_1(int n)
{
    return n&(n-1);
}
 
int abss(int a)
{
    return a>0?a:-a;
}
 
double fabss(double a)
{
    return a>0?a:-a;
}
 
int minn(int a,int b)
{
    return a<b?a:b;
}