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;}
