[30] CSP 加赛 1

A.小W与伙伴招募

考虑贪心，可以发现，每一天只需要优先选择价值低的即可

这种贪心思路有一个错误的扩展，就是先把 \(m\) 天的货一次性补齐再一次性买，这样做的问题在于有可能买到次日的货，而这样做是不被允许的

考虑放到线段树上，维护 “节点能够提供的钻石数量” 和 “节点花费” 两个值，只要我们保证价格在线段树上递增排列（这是很好做到的，排序再建树即可），那么我们就可以通过和平衡树类似的二分来向下递归

• 如果左子树满足当前要求，直接在左子树里买
• 否则，先把左子树买完，再在右子树里买

然后考虑怎么维护这两个值

每次补货只能单点修改，复杂度显然太高了，因此，我们设计节点数量 \(t=kb_i+s\)，其中 \(b_i\) 为 \(i\) 的每日补货数量，这样我们在每一天新开始的时候，只需要让所有的 \(k\) 都增加 \(1\) 就可以了，而这在线段树上是容易实现的

介于我们并不能同时维护加和乘，所以开两棵线段树（当然也可以合成一颗，不过两者的维护是完全没有关系的），然后在父结点上维护子节点权值和即可

还有问题就是怎么在补货之后比较快地实现 pushdown，可以在外面开两个前缀和来实现（分别对应两颗线段树）

然后是 lazytag，针对本题需要开两个 tag，一个维护补货时候的 k 增量，一个维护买了东西以后的整体清空，执行的时候先清空再增，注意顺序

\(-1\) 直接赋成 \(1e6\) 就行了

另外需要注意的就是，不要直接对 \(m\) 建树，可以考虑微调一下 sort，让价值相同的中，数量最多的排在前面，然后你只要遇到一个 \(-1\) 就说明你一直买这个就行了（后面的都更贵），因此直接对此时的 \(i\) 建树就行了

不过我不明白为啥对 \(m\) 建树会导致答案错掉

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
template<typename T>
void read(T& x){
	x=0;bool sym=0;char c=getchar();
    while(!isdigit(c)){sym^=(c=='-');c=getchar();}
    while(isdigit(c)){x=x*10+c-48;c=getchar();}
    if(sym)x=-x;
}
template<typename T,typename... Args>
void read(T& x,Args&... args){
    read(x);read(args...);
}
#define int long long
struct tree{
	int l,r;
	int tot_sum,cost_sum;
	int lazy_cover,lazy_k;
}t[200001*4];
int tot_sum[200001],cost_sum[200001];
struct item{
	int a,b;
	bool operator <(const item &A)const{
		if(a==A.a) return b>A.b;
		return a<A.a;
	}
}w[200001];
#ifndef TOOL_H
#define TOOL_H
#endif
template<typename T>
T floor_sqrt(T x,T l=1,T r=-1){
	if(r==-1) r=x;
	int ans=-1;
	while(l<=r){
		int mid=(l+r)/2;
		if(mid*mid<=x){
			l=mid+1;
			ans=mid;
		}
		else{
			r=mid-1;
		}
	}
	return ans;
}
void print(__int128 x,bool first=true){
	if(x<0){
		putchar('-');
		print(-x,false);
		return;
	}
	if(x==0){
		if(first) putchar('0');
		return;
	}
	print(x/10,false);
	putchar((int)(x%10)+'0');
}
template<typename T>
std::string to_string(T x){
	std::string res;bool f=false;
	if(x<0){
		f=true;
		x*=-1;
	}
	while(x){
		res.push_back((int)(x%10)+'0');
		x/=10;
	}
	reverse(res.begin(),res.end());
	if(f) res.push_back('-');
	if(res.empty()) res.push_back('0');
	return res;
}
long long to_number(std::string x){
	long long res=0;bool f=false;
	for(int i=0;i<=(int)x.length()-1;++i){
		if(x[i]=='-'){
			f=true;
		}
		else{
			res=res*10+x[i]-'0';
		}
	}
	return res*(f?-1:1);
}
/*------TOOL_H------*/
#define tol (id*2)
#define tor (id*2+1)
#define mid(l,r) mid=((l)+(r))/2
void build(int id,int l,int r){
	t[id].l=l;
	t[id].r=r;
	if(l==r) return;
	int mid(l,r);
	build(tol,l,mid);
	build(tor,mid+1,r);
}
void update(int id){
	t[id].tot_sum=t[tol].tot_sum+t[tor].tot_sum;
	t[id].cost_sum=t[tol].cost_sum+t[tor].cost_sum;
}
void pushdown_cover(int id){
	if(t[id].lazy_cover){
		t[tol].tot_sum=t[tol].cost_sum=0;
		t[tor].tot_sum=t[tor].cost_sum=0;
		t[tol].lazy_k=t[tor].lazy_k=0;
		t[tol].lazy_cover=t[tor].lazy_cover=1;
		t[id].lazy_cover=0;
	}
}
void pushdown_k(int id){
	if(t[id].lazy_k){
		t[tol].tot_sum+=t[id].lazy_k*(tot_sum[t[tol].r]-tot_sum[t[tol].l-1]);
		t[tor].tot_sum+=t[id].lazy_k*(tot_sum[t[tor].r]-tot_sum[t[tor].l-1]);
		t[tol].cost_sum+=t[id].lazy_k*(cost_sum[t[tol].r]-cost_sum[t[tol].l-1]);
		t[tor].cost_sum+=t[id].lazy_k*(cost_sum[t[tor].r]-cost_sum[t[tor].l-1]);
		t[tol].lazy_k+=t[id].lazy_k;
		t[tor].lazy_k+=t[id].lazy_k;
		t[id].lazy_k=0;
	}
}
void change(int id,int k){
	if(k>0){
		t[id].tot_sum+=(tot_sum[t[id].r]-tot_sum[t[id].l-1]);
		t[id].cost_sum+=(cost_sum[t[id].r]-cost_sum[t[id].l-1]);
		t[id].lazy_k+=k;
	}
	else{
		t[id].tot_sum=0;
		t[id].cost_sum=0;
		t[id].lazy_k=0;
		t[id].lazy_cover=1;
	}
}
int ask(int id,int k){
	if(t[id].l==t[id].r){
		t[id].tot_sum-=k;
		t[id].cost_sum-=w[t[id].l].a*k;
		return w[t[id].l].a*k;
	}
	pushdown_cover(id);
	pushdown_k(id);
	int res=0;
	if(k<=t[tol].tot_sum){
		res=ask(tol,k);
	}
	else{
		res=t[tol].cost_sum+ask(tor,k-t[tol].tot_sum);
		change(tol,-1);
	}
	update(id);
	return res;
}
int n,m;
int c[200001];
const int inf=1e6;
signed main(){
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	read(n,m);
	for(int i=1;i<=n;++i){
		read(c[i]);
	}
	for(int i=1;i<=m;++i){
		read(w[i].a,w[i].b);
		if(w[i].b==-1) w[i].b=inf;
	}
	sort(w+1,w+m+1);
	for(int i=1;i<=m;++i){
		tot_sum[i]=tot_sum[i-1]+w[i].b;
		cost_sum[i]=cost_sum[i-1]+w[i].a*w[i].b;
		if(w[i].b==inf){
			build(1,1,i);
			break;
		}
	}
	int ans=0;
	for(int i=1;i<=n;++i){
		change(1,1);
		ans+=ask(1,c[i]);
	}
	print(ans);
}

B.小W与制胡串谜题

[](string a,string b){return a+b<b+a;}