分析:
显然,如果一个勇士(没错,我就是愿意称这些人为勇士)弱到一个敌人也干不掉,那么我们就可以把ta开了
每个人只有攻击比ta弱的敌人才有意义
于是我就建出如下的网络(忽略GG的勇士,每个勇士只向比ta弱的敌人连边):
问了一下舒老师,舒老师给出了另一种建图方法(包含题目给出所有信息):
从勇士直接连向汇点,表示不启用这个勇士
这样我们求一个最大费用最大流即可
然而发现网上并没有网络流算法。。。
dada们就当玩笑看看吧
方法一:贪心
先将
a
a
和放在一起从小到大排序,相等的话
a
a
放前面
开一个优先队列维护敌人价值
对于每一个
ai
a
i
,如果当前在优先队列中有敌人可以打,那么就打掉
否则我们可以丢掉一个
a
a
最小的勇士,显然是更优的。
做完这个操作以后我们会得到一个选择最多队友情况下的最优解,但不一定是本题要求的最优(可能是负数,这时舍弃掉一些敌人反而更优)
那我们怎么解决这个问题呢?
显然,我们每次丢掉一个
a
a
最小的勇士,同时丢掉一个最小的敌人,得到一组新的解,判断这组解是否更优
方法二:线段树模拟费用流
官方题解:
不难发现 a a 越大的玩家越容易占领房子,并且收益越大,因此最优解中一定是选最大的若干个玩家
为了方便起见,我们设
v[i]=c[i]−b[i]
v
[
i
]
=
c
[
i
]
−
b
[
i
]
,即每个房子的收益。
将玩家和房子混在一起,按
a或b
a
或
b
从小到大排序,对于相同的情况,将玩家优先放在前面,那么每个玩家能占领的房子就是它前面的所有房子
如果我们将方案中选取的玩家看成右括号,房子看成左括号,那么方案必定是一个合法的括号序列
即设 s[i] s [ i ] 表示前 i i 个位置中选取的房子减去玩家的个数,那么必有且 s[n+m]=0 s [ n + m ] = 0
因为
a
a
越大越好,因此我们从大到小考虑每个玩家
对于当前这个玩家,我们先将其位置填上右括号,对应中一段后缀减去1
我们希望找到一个没用过的收益最大的房子,满足加入那个房子后仍然是一个合法的括号序列
假设房子位于位置
j
j
,那么加入会导致
s[j..n+m]
s
[
j
.
.
n
+
m
]
加上1,
因此只要
min(s[1..j−1])≥0
m
i
n
(
s
[
1..
j
−
1
]
)
≥
0
且
min(s[j..n+m])≥−1
m
i
n
(
s
[
j
.
.
n
+
m
]
)
≥
−
1
即是合法的房子
而区间加减、 区间最小值查询则是线段树的经典操作
按 v v 从大到小考虑每个未使用的房子,如果它合法,那么将其纳入答案,同时加入该左括号,然后考虑下一个玩家
如果非法,因为我们按照从大到小考虑每个玩家,今后的条件只会越来越苛刻,因此它永远都不可能合法,直接抛弃即可
注意到上述问题本质是在用线段树模拟费用流的增广,因此当增广路长度 <0 < 0 <script type="math/tex" id="MathJax-Element-55"><0</script>时,即可终止算法
时间复杂度 O((n+m)log(n+m)) O ( ( n + m ) l o g ( 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;
}