Codeforces Round #757 (Div. 2)

A. Divan and a Store

给你$N$个物品，每个物品有相应的价格$a_i$，你有$K$元，问最多能买多少个价格在$[l,r]$之间的物品
$1 \leq N \leq 100$

$N$很小，将物品从小到大排序，依次购买即可。

$code:$

#include<bits/stdc++.h>
using namespace std;
int t,n,l,r,k;
const int MAX_N = 100 + 5;
int a[MAX_N];
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d%d%d%d",&n,&l,&r,&k);
		for(int i=1;i<=n;i++){
			scanf("%d",&a[i]);
		}
		sort(a+1,a+1+n);
		int cnt=0;
		for(int i=1;i<=n;i++){
			if(a[i]>=l && a[i]<=r){
				if(k>=a[i]){
					k-=a[i];
					cnt++;
				}
				else break;
			}
		}
		printf("%d\n",cnt);
	}
	return 0;
}

B. Divan and a New Project

在坐标轴上，你需要确定$N$个点的坐标，每个点需要到达$a_i$次，从$0$号点到$i$号点的距离为$2|x_0-x_i|$，问最少需要走多少距离，并构造出任意一种方案。

按权值（到达次数）从大到小排序，对于权值大的点放在离$0$号节点近的地方。

$code:$

#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 200000 + 5;
int t,n,ans[MAX_N];
struct node{
	int x,id;
}a[MAX_N];
bool cmpx(node a,node b){
	return a.x>b.x;
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i=1;i<=n;i++){
			scanf("%d",&a[i].x);
			a[i].id=i;
		}
		sort(a+1,a+1+n,cmpx);
		ans[0]=0;
		int cnt1=0,cnt2=0;
		for(int i=1;i<=n;i++){
			if(i&1) ans[a[i].id]=++cnt1;
			else ans[a[i].id]=--cnt2;
		}
//		printf("\n");
		long long res=0;
		for(int i=1;i<=n;i++){
			res+=2ll*abs(ans[a[i].id])*a[i].x;
		}
		printf("%lld\n",res);
		for(int i=0;i<=n;i++){
			printf("%d ",ans[i]);
		}
		printf("\n");
	}
	return 0;
}

C. Divan and bitwise operations

位运算你能不能去死啊！！！
一个长度为$N$的序列，但你不知道序列的具体元素，只知道$m$段区间按位或的值，求这个序列的子序列（子集）异或和的和。

自闭题
这是一个场上还原了序列但不会统计答案的SB。

当我们确定序列后，考虑如何计算答案。
发现，如果枚举子集肯定是不合理的，也想不到什么方法可以优化，但求的是异或和的和，考虑二进制下每一位单独考虑，对于第$i$位，序列中第$i$位为1的数有$cnt1$个，为0的有$cnt2$个，对于为0的情况，选或不选都行，贡献为$2^{cnt2}$，考虑为1的情况，发现只有当选择个数为奇数时，该为才会为1，所以贡献为$C_{cnt1}^1+C_{cnt1}^3+...+C_{cnt1}^{2k-1} = 2^{cnt1-1}$，所以贡献为$2^{cnt1-1}*2^{cnt2}*2^i$

考虑如何还原原序列，可以发现，题目给定的限制是区间按位或的值。因为是按位或，所以二进制为0的位置，这区间的数二进制下该位置一定都为0。

于是使这个数能为1的地方都为1，随便拿个什么东西来维护就行了，例如：线段树，对每一位差分数组....

时间复杂度$O(nlogn)$

但是，发现答案式子$2^{cnt1-1}*2^{cnt2}*2^i = 2^{n-1}*2^i$那么只要第$i$位，$n$个数不全是0，那么都是必定有贡献的，所以将每个按位或和按位或起来，得到的$X$就等于$\sum 2^i (第i位为1)$

时间复杂度$O(n)$

$code: O(nlogn)$

#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 200000 + 5;
const int mod = 1e9 + 7;
int t,n,m,ans[MAX_N];
struct node{
	int l,r,x;
}p[MAX_N];
namespace SegmentTree{
	#define ls ((p)<<1)
	#define rs ((p)<<1|1)
	int lazy[MAX_N<<2];
	void build(int p,int l,int r){
		lazy[p]=(1<<30)-1;
		if(l==r){
			return;
		}
		int mid=l+r>>1;
		build(ls,l,mid);
		build(rs,mid+1,r);
	}
	void pushdown(int p,int l,int r){
		if(lazy[p]==(1<<30)-1) return;
		lazy[ls]&=lazy[p];
		lazy[rs]&=lazy[p];
		lazy[p]=(1<<30)-1;
	}
	void modify(int p,int l,int r,int L,int R,int x){
		if(L<=l && r<=R){
			lazy[p]&=x;
			return;
		}
		pushdown(p,l,r);
		int mid=l+r>>1;
		if(L<=mid) modify(ls,l,mid,L,R,x);
		if(mid<R) modify(rs,mid+1,r,L,R,x);
	}
	int query(int p,int l,int r,int x){
		if(l==r){
			return lazy[p];
		}
		pushdown(p,l,r);
		int mid=l+r>>1;
		if(x<=mid) return query(ls,l,mid,x);
		else return query(rs,mid+1,r,x);
	}
}
inline void add(int &x,int y){
	x+=y;
	if(x>=mod) x-=mod;
}
int x[MAX_N];
int ksm(int x,int y){
	int res=1;
	while(y){
		if(y&1) res=1ll*res*x%mod;
		x=1ll*x*x%mod;
		y>>=1;
	}
	return res;
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++) ans[i]=(1<<30)-1;
		SegmentTree::build(1,1,n);
		for(int i=1;i<=m;i++){
			scanf("%d%d%d",&p[i].l,&p[i].r,&p[i].x);
			SegmentTree::modify(1,1,n,p[i].l,p[i].r,p[i].x);
		}
		for(int i=1;i<=n;i++) ans[i]=SegmentTree::query(1,1,n,i);
		int cnt[2];
		int Ans=0;
		for(int k=0;k<30;k++){
			cnt[0]=cnt[1]=0;
			int tmp=0;
			for(int i=1;i<=n;i++){
				cnt[(ans[i]>>k)&1]++;
			}
			if(cnt[1]) add(Ans,1ll*ksm(2,cnt[0])*ksm(2,cnt[1]-1)%mod*(1<<k)%mod);
		}
//		add(Ans,Ans);
		printf("%d\n",Ans);
	}
	return 0;
}