【Codeforces 482B Interesting Array】线段树

题目传送门

题目大意

给出许多 l、r、q，构造一个数列，满足每一个从 l 到 r 的按位与结果为 q 。

思路1 差分

$s[i]$表示第$i$个要求，由三个东西组成~
题目中有所以就不介绍啦（手动滑稽
首先，建立一个数组~
$part[i][j]$表示我们要求的数列中的第$i$个数，二进制第$j$位为几。
因为有$10^5$个限制，每个都修改一遍很可能会超时，所以我们用差分来表示。也就是这个亚子：

if (s[i].q & (1<<j)){ // 如果s[i].q 的第j位为 1 
	part[s[i].x][j] ++; //差分，x~y这一位都+1 
	part[s[i].y+1][j] --;//也就相当于在y+1这里前缀和再-1
}

让每个要求都这么满足了之后，就可以把差分去掉啦！顺便计算出来我们此时决定好的数组$a[i]$，它有可能是答案，也有可能不是哦~

for (int j=0;j<30;j++){
	for (int i=1;i<=n;i++){
		part[i][j] += part[i-1][j];//把差分变正常 
		if (part[i][j]) a[i] = a[i]|(1<<j);//如果正常之后这个数的这一位不等于0 
	}//把这个1补在a【i】的那一位上 
}

为什么会不是呢？因为不是所有的要求都可以共存的嘛！
我们需要一个数据结构，来让我们方便地求出每一个区间的&和。
因为&是可以传递的！所以当然是可怕的线段树了嘤~

build(1,n,1);
for (int i=1;i<=m;i++){
	int x=query(s[i].x,s[i].y,1,n,1);
	//查询，看看是否满足每个要求 
	if (x!=s[i].q) {
		cout<<"NO\n";
		return 0;
	}
}
cout<<"YES\n";

然后，再把我们的$a[i]$输出就好啦！

思路2 区间修改+区间查询

差分求答案需要先求出来数组再建树，那么可不可以直接在建树的时候就求出来答案的数组，然后再直接查询呢？
当然阔以！
对于每一条限制，都这样update一下！

inline void update(int root,int l,int r,int val){
    if(tr[root].l==l&&tr[root].r==r){
        tr[root].sum|=val;
        tr[root].lazy|=val;
        return ;
    }
    if(tr[root].lazy) push_down(root);
    register int mid=(tr[root].l+tr[root].r)>>1;
    if(mid<l)  update(rson,l,r,val);
    else  if(mid>=r) update(lson,l,r,val);
    else{
        update(lson,l,mid,val);
        update(rson,mid+1,r,val);
        }
    push_up(root);
}

然后再老样子查询，就阔以啦！
从下往上走是&，从上往下走是 | 。

差分版本代码

代码全文感谢zzy小公举！

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+100;
int n,m;
struct node{
	int x,y,q;
}s[maxn];
int a[maxn];
int part[maxn][40];
int t[maxn<<2];
inline void push_up(int x){
	t[x]=t[x<<1]&t[x<<1|1];
}
inline void build(int l,int r,int rt){  
	if (l==r){
		t[rt]=a[l];
		return;
	}
	int mid=(l+r)>>1;
	build(l,mid,rt<<1);
	build(mid+1,r,rt<<1|1);
	push_up(rt);
}
int query(int ll,int rr,int l,int r,int rt){
	if (l>=ll&&r<=rr){
		return t[rt];
	}
	int mid=(l+r)>>1;
	if (rr<=mid) return query(ll,rr,l,mid,rt<<1);
	else if (ll>mid) return query(ll,rr,mid+1,r,rt<<1|1);
	else return query(ll,rr,l,mid,rt<<1)&query(ll,rr,mid+1,r,rt<<1|1);
}
int main(){
	ios::sync_with_stdio(false);
	cin >> n >> m;
	for (int i=1;i<=m;i++){
		cin>>s[i].x>>s[i].y>>s[i].q;
	}
	for (int i=1;i<=m;i++){
		for (int j=0;j<30;j++){
			if (s[i].q & (1<<j)){ // 如果s[i].q 的第j位为 1 
				part[s[i].x][j] ++; //差分，x~y这一位都+1 
				part[s[i].y+1][j] --;
			}
		}
	}
	for (int j=0;j<30;j++){
		for (int i=1;i<=n;i++){
			part[i][j] += part[i-1][j];//把差分变正常 
			if (part[i][j]) a[i] = a[i]|(1<<j);//如果正常之后这个数的这一位不等于0 
		}//把这个1补在a【i】的那一位上 
	}
	build(1,n,1);
	for (int i=1;i<=m;i++){
		int x=query(s[i].x,s[i].y,1,n,1);
		//查询，看看是否满足每个要求 
		if (x!=s[i].q) {
			cout<<"NO\n";
			return 0;
		}
	}
	cout<<"YES\n";
	for (int i=1;i<=n;i++) cout<<a[i]<<" ";
	cout<<endl;
	return 0;
}

区间修改区间查询版本代码

其实是来源于这里啦

#include<ctime>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define lson root<<1
#define rson root<<1|1
using namespace std;

struct oper
{
    int l,r,a;
} op[100010];

struct node
{
    int l,r,lazy,sum;
} tr[400010];

inline void push_up(int root)
{
    tr[root].sum=tr[lson].sum&tr[rson].sum;
}

inline void push_down(int root)
{
    tr[lson].sum|=tr[root].lazy;
    tr[lson].lazy|=tr[root].lazy;
    tr[rson].sum|=tr[root].lazy;
    tr[rson].lazy|=tr[root].lazy;
    tr[root].lazy=0;
}

inline void build(int root,int l,int r)
{
    if(l==r)
    {
        tr[root].l=l;
        tr[root].r=r;
        return ;
    }
    tr[root].l=l;
    tr[root].r=r;
    register int mid=(l+r)>>1;
    build(lson,l,mid);
    build(rson,mid+1,r);
}

inline void update(int root,int l,int r,int val)
{
    if(tr[root].l==l&&tr[root].r==r)
    {
        tr[root].sum|=val;
        tr[root].lazy|=val;
        return ;
    }
    if(tr[root].lazy)
    {
        push_down(root);
    }
    register int mid=(tr[root].l+tr[root].r)>>1;
    if(mid<l)
    {
        update(rson,l,r,val);
    }
    else
    {
        if(mid>=r)
        {
            update(lson,l,r,val);
        }
        else
        {
            update(lson,l,mid,val);
            update(rson,mid+1,r,val);
        }
    }
    push_up(root);
}

inline int query(int root,int l,int r)
{
    if(tr[root].l==l&&tr[root].r==r)
    {
        return tr[root].sum;
    }
    if(tr[root].lazy)
    {
        push_down(root);
    }
    register int mid=(tr[root].l+tr[root].r)>>1;
    if(mid<l)
    {
        return query(rson,l,r);
    }
    else
    {
        if(mid>=r)
        {
            return query(lson,l,r);
        }
        else
        {
            return query(lson,l,mid)&query(rson,mid+1,r);
        }
    }
}

int main()
{
    int n,m,flag=0;
    scanf("%d%d",&n,&m);
    build(1,1,n);
    for(int i=1; i<=m; i++)
    {
        scanf("%d%d%d",&op[i].l,&op[i].r,&op[i].a);
        update(1,op[i].l,op[i].r,op[i].a);
    }
    for(int i=1; i<=m; i++)
    {
        if(query(1,op[i].l,op[i].r)!=op[i].a)
        {
            flag=1;
        }
    }
    if(flag)
    {
        puts("NO");
    }
    else
    {
        puts("YES");
        for(int i=1; i<=n; i++)
        {
            printf("%d ",query(1,i,i));
        }
    }
}

---

完结~
撒花~~~~~~~~
★,°:.☆(￣▽￣)/$:.°★ 。