bzoj4977 [Lydsy八月月赛]跳伞求生（线段树模拟费用流||贪心）

题目链接

分析：
显然，如果一个勇士（没错，我就是愿意称这些人为勇士）弱到一个敌人也干不掉，那么我们就可以把ta开了
每个人只有攻击比ta弱的敌人才有意义
于是我就建出如下的网络（忽略GG的勇士，每个勇士只向比ta弱的敌人连边）：

问了一下舒老师，舒老师给出了另一种建图方法（包含题目给出所有信息）：

从勇士直接连向汇点，表示不启用这个勇士
这样我们求一个最大费用最大流即可

然而发现网上并没有网络流算法。。。
dada们就当玩笑看看吧

---

方法一：贪心

先将$a$和$b$放在一起从小到大排序，相等的话$a$放前面
开一个优先队列维护敌人价值$c−b$
对于每一个$a_i$，如果当前在优先队列中有敌人可以打，那么就打掉
否则我们可以丢掉一个$a$最小的勇士，显然是更优的。

做完这个操作以后我们会得到一个选择最多队友情况下的最优解，但不一定是本题要求的最优（$c−b$可能是负数，这时舍弃掉一些敌人反而更优）

那我们怎么解决这个问题呢？
显然，我们每次丢掉一个$a$最小的勇士，同时丢掉一个$c−b$最小的敌人，得到一组新的解，判断这组解是否更优

---

方法二：线段树模拟费用流

官方题解：

不难发现$a$越大的玩家越容易占领房子，并且收益越大，因此最优解中一定是选$a$最大的若干个玩家

为了方便起见，我们设$v[i]=c[i]−b[i]$，即每个房子的收益。
将玩家和房子混在一起，按$a或b$从小到大排序，对于相同的情况，将玩家优先放在前面，那么每个玩家能占领的房子就是它前面的所有房子

如果我们将方案中选取的玩家看成右括号，房子看成左括号，那么方案必定是一个合法的括号序列

即设$s[i]$表示前$i$个位置中选取的房子减去玩家的个数，那么必有$min(s[i])≥0$且$s[n+m]=0$

因为$a$越大越好，因此我们从大到小考虑每个玩家
对于当前这个玩家，我们先将其位置填上右括号，对应$s$中一段后缀减去1

我们希望找到一个没用过的收益最大的房子，满足加入那个房子后仍然是一个合法的括号序列
假设房子位于位置$j$，那么加入$j$会导致$s[j..n+m]$加上1，

因此只要$min(s[1..j−1])≥0$且$min(s[j..n+m])≥−1$即是合法的房子
而区间加减、 区间最小值查询则是线段树的经典操作

按$v$从大到小考虑每个未使用的房子，如果它合法，那么将其纳入答案，同时加入该左括号，然后考虑下一个玩家

如果非法，因为我们按照$a$从大到小考虑每个玩家，今后的条件只会越来越苛刻，因此它永远都不可能合法，直接抛弃即可

注意到上述问题本质是在用线段树模拟费用流的增广，因此当增广路长度 <0 < 0 <script type="math/tex" id="MathJax-Element-55"><0</script>时，即可终止算法

时间复杂度$O((n+m)log(n+m))$

tip

最近看题解发现出现了很多线duang树。。。什么新梗？？？

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long

using namespace std;

const int N=100010;
const int INF=1e9;
struct node{          //用线段树维护前缀和 
    int mn,ad;
};
node t[N<<2];
struct point{
    int x,type;
};
point po[N<<1],b[N];
int n,m,nn,a[N],w[N<<1];

int cmp(const point &A,const point &B) {   //按照a或b排序 
    return A.x<B.x||(A.x==B.x&&A.type<B.type);   
}

void push(int bh,int l,int r) {
    if (l==r) return;
    if (!t[bh].ad) return;
    int lc=bh<<1;
    int rc=bh<<1|1;
    t[lc].mn+=t[bh].ad; t[lc].ad+=t[bh].ad;
    t[rc].mn+=t[bh].ad; t[rc].ad+=t[bh].ad;
    t[bh].ad=0;
}

void update(int bh) {
    int lc=bh<<1;
    int rc=bh<<1|1;
    t[bh].mn=min(t[lc].mn,t[rc].mn);
}

void add(int bh,int l,int r,int L,int R,int z) {
    if (R<L) return;
    push(bh,l,r);
    if (l>=L&&r<=R) {
        t[bh].mn+=z;
        t[bh].ad+=z;
        return;
    }
    int mid=(l+r)>>1;
    if (L<=mid) add(bh<<1,l,mid,L,R,z);
    if (R>mid) add(bh<<1|1,mid+1,r,L,R,z);
    update(bh);
}

int ask(int bh,int l,int r,int L,int R) {
    if (R<L) return INF;
    push(bh,l,r);
    if (l>=L&&r<=R) return t[bh].mn;
    int ans=INF;
    int mid=(l+r)>>1;
    if (L<=mid) ans=min(ans,ask(bh<<1,l,mid,L,R));
    if (R>mid) ans=min(ans,ask(bh<<1|1,mid+1,r,L,R));
    return ans;
}

void solve(){
    ll ans=0;
    for (int i=n,j=m;i;i--,j--) {
        add(1,1,nn,w[i],nn,-1);
        for (;j;j--) {
            int k=w[b[j].type+n];
            if (ask(1,1,nn,1,k-1)>=0&&ask(1,1,nn,k,nn)>=-1&&a[i]+b[j].x>0) {
                ans+=(ll)a[i]+b[j].x;
                add(1,1,nn,k,nn,1);
                break;
            }
        }
        if (!j) break;
    }
    printf("%lld\n",ans);
}

int main() 
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    sort(a+1,a+1+n);
    for (int i=1;i<=n;i++) po[i].x=a[i],po[i].type=i;
    for (int i=1;i<=m;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        po[i+n].x=x; po[i+n].type=i+n; 
        b[i].x=y-x; b[i].type=i;
    }
    nn=n+m;
    sort(po+1,po+1+nn,cmp); sort(b+1,b+1+m,cmp);
    for (int i=1;i<=nn;i++) w[po[i].type]=i;
    solve();
    return 0;
}