POI2011 Meteors

Meteors

POI2011

题意

1.有N个国家

2.有一颗星球的轨道被分为M份(第M份和第1份相邻)，第i份上有第Ai个国家的太空站。

3.这个星球经常会下陨石雨。已知接下来K场陨石雨的情况。

4.第i个国家希望能够收集Pi单位的陨石样本

5.判断对于每个国家，它需要在第几次陨石雨之后，才能收集足够的陨石

解

1.“第几次足够”，看到这个，当然是二分啦

2.然后有好多好多国家，当然是同时二分啦

3.solve(L,R,Lt,Rt)
mid=Lt+Rt>>1
用BIT求出[Lt,mid]的陨石会砸哪些区域
对于[L,R]的询问，
先把每个国家的区域用vector存下来，这样所有国家的查询，均摊复杂度为O(n)
先查询出这个询问(国家)当前了收集多少陨石，
如果>=P[i],扔到左边
否则，P[i]-=query(),然后扔到右边
这样对于扔到右边的点，前面的贡献已经计算过了，下次就不必再扫一遍，复杂度稳定

具体代码

#include
using namespace std;
const int M=300005;
int n,m,K,ans[M];
vector<int>G[M];
struct BIT {
	long long sum[M];
	void clear() {
		for(int i=1; i<=m; i++)sum[i]=0;
	}
	void add(int x,int a) {
		while(x<=m) {
			sum[x]+=a;
			x+=-x&x;
		}
	}
	long long query(int x) {
		long long res=0;
		while(x) {
			if(res<1e9)res+=sum[x];
			x-=-x&x;
		}
		return res;
	}
} BIT;
struct Query {
	int L,R,a;
} Q[M];
struct node {
	int id,P;
} A[M],B[M];
int T;
void add(int k,int f) {
	if(Q[k].L<=Q[k].R) {
		BIT.add(Q[k].L,Q[k].a*f);
		BIT.add(Q[k].R+1,-Q[k].a*f);
	} else {
		BIT.add(Q[k].L,Q[k].a*f);
		BIT.add(m+1,-Q[k].a*f);
		BIT.add(1,Q[k].a*f);
		BIT.add(Q[k].R+1,-Q[k].a*f);
	}
}
void solve(int L,int R,int Lt,int Rt) {
	if(L>R||Lt>Rt)return ;
	int mid=Lt+Rt>>1;
	for(int i=Lt; i<=mid; i++)add(i,1);
	int l1=L,l2=R;
	for(int i=L; i<=R; i++) {
		long long tot=0;
		for(int j=0; j<G[A[i].id].size(); j++) {
			int y=G[A[i].id][j];
			if(tot<1e9)tot+=BIT.query(y);
		}
		if(tot>=A[i].P)ans[A[i].id]=mid,B[l1++]=A[i];
		else A[i].P-=tot,B[l2--]=A[i];
	}
	for(int i=Lt; i<=mid; i++)add(i,-1);
	for(int i=L; i<=R; i++) {
		A[i]=B[i];
	}
	solve(L,l1-1,Lt,mid-1);
	solve(l2+1,R,mid+1,Rt);
}
int main() {
	int x;
	scanf("%d %d",&n,&m);
	for(int i=1; i<=m; i++) {
		scanf("%d",&x);
		G[x].push_back(i);
	}
	for(int i=1; i<=n; i++) {
		A[i].id=i;
		ans[i]=-1;
		scanf("%d",&A[i].P);
	}
	scanf("%d",&K);
	for(int i=1; i<=K; i++) {
		scanf("%d %d %d",&Q[i].L,&Q[i].R,&Q[i].a);
	}
	BIT.clear();
	solve(1,n,1,K);
	for(int i=1; i<=n; i++) {
		if(ans[i]==-1)printf("NIE\n");
		else printf("%d\n",ans[i]);
	}
	return 0;
}