[hdu7182]Fall with Full Star

将所有关卡分为$d_{i}\ge 0$和$d_{i}<0$两类，显然优先选前者，即两部分独立

在此基础上，将后者的过程倒序并简单处理，即可转化为与前者相同的子问题

关于子问题，考虑钦定贡献关卡，显然优先选其余关卡，且"钦定关卡"按$s_{i}-d_{i}$从小到大

将所有关卡按$s_{i}-d_{i}$从小到大排序，有以下两种做法——

做法1-dp

定义$f_{i,j}$表示$[i,n]$中钦定$j$个关卡时最小的$\sum_{钦定i}d_{i}$，转移即
$$
f_{i,j}=\min\left(f_{i+1,j},\begin{cases}f_{i+1,j-1}+d_{i}&f_{i+1,j-1}\le s_{0}+\sum d_{i}-s_{i}\\\infty &f_{i+1,j-1}>s_{0}+\sum d_{i}-s_{i}\end{cases}\right)
$$
显然$f_{i,j}$关于$j$单调不降，且具有凸性（即$\Delta f_{i,j}=f_{i,j+1}-f_{i,j}$同样单调不降）

此时，取$j=\max_{f_{i+1,j_{0}}\le s_{0}+\sum d_{i}-s_{i}}j_{0}$，转移也即在$\Delta f_{i+1,[0,j]}$中插入$d_{i}$并删除最大值

（另外，关于凸性的证明，结合上述过程归纳即可）

使用平衡树维护，时间复杂度为$o(n\log n)$，可以通过

做法2-贪心

从后往前，维护当前最优解（及对应方案），并分类讨论：

1.若能钦定$i$，则直接钦定即可

2.若不能钦定$i$且删除最优解中$d_{i}$最大的位置后可以钦定$i$，则删除后钦定

3.若均不能，则不钦定$i$，直接跳过即可

（贪心的正确性不太会证QAQ）

用set维护选中的$d_{i}$即可，时间复杂度也为$o(n\log n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define ll long long
int t,n,na,nb,x,ans;ll s,y;
multiset<int>S;
struct Data{
    int d;ll s;
    bool operator < (const Data &n)const{
        return s-d<n.s-n.d;
    }
}a[N],b[N];
void calc(int n,ll s,Data *a){
    sort(a+1,a+n+1);
    for(int i=1;i<=n;i++)s+=a[i].d;
    ll sum=0;S.clear();
    for(int i=n;i;i--){
        if (sum<=s-a[i].s)sum+=a[i].d,S.insert(a[i].d);
        else{
            if (S.empty())continue;
            int k=(*--S.end());
            if (sum-k<=s-a[i].s){
                sum+=a[i].d-k;
                S.erase(--S.end()),S.insert(a[i].d);
            }
        }
    }
    ans+=S.size();
}
int main(){
    scanf("%d",&t);
    while (t--){
        scanf("%d%lld",&n,&s);
        na=nb=ans=0;
        for(int i=1;i<=n;i++){
            scanf("%d%lld",&x,&y);
            if (x>=0)a[++na]=Data{x,y};
            else b[++nb]=Data{-x,y-x};
        }
        calc(na,s,a);
        for(int i=1;i<=na;i++)s+=a[i].d;
        for(int i=1;i<=nb;i++)s-=b[i].d;
        calc(nb,s,b),printf("%d\n",ans);
    }
    return 0;
}