4276: [ONTAK2015]Bajtman i Okrągły Robin 费用流+线段树优化建图/贪心

费用流作法是最暴力最显然的吧。。

一眼建图题，所以裸的是水不过去的。。

朴素建图：用xi表示每个强盗，用yi表示区间[i,i+1]。

(S,xi,1,ci)

(xi,yi(ai<=yi<bi),1,0)

(yi,T,1,0)

然后这样是过不了的。

我们发现每次连边都是左边一个点对应右边一段连续的区间，所以可以用线段树来优化。

在原来的基础上，我们不再从xi向每个对应的yi连边，而用线段树中的点来表示区间[ai,bi)，然后连边。对于线段树中的点，由父亲向儿子连容量为inf，费用为0的边。由叶子节点向汇点T连容量为1，费用为0的边。然后跑费用流。

28s…还是很慢

#include<iostream>
#include<cstdio>
#include<cstring>
#define inf 1000000007
#define N 30005
#define M 200005
using namespace std;
int n,S,T,ans,cnt=1,num;
int l
,r
,id
;
int head
,dis
,path
,q
;
int next[M],list[M],flow[M],cost[M],from[M];
bool vis
;
inline int read()
{
int a=0,f=1; char c=getchar();
while (c<'0'||c>'9') {if (c=='-') f=-1; c=getchar();}
while (c>='0'&&c<='9') {a=a*10+c-'0'; c=getchar();}
return a*f;
}
inline void insert(int x,int y,int w,int z)
{
next[++cnt]=head[x];
head[x]=cnt;
list[cnt]=y;
from[cnt]=x;
flow[cnt]=w;
cost[cnt]=z;
}
inline void build(int k,int x,int y)
{
l[k]=x; r[k]=y; id[k]=++num;
if (l[k]==r[k])
{
insert(id[k],T,1,0); insert(T,id[k],0,0);
return;
}
int mid=l[k]+r[k]>>1;
build(k<<1,x,mid); build(k<<1|1,mid+1,y);
insert(id[k],id[k<<1],inf,0); insert(id[k<<1],id[k],0,0);
insert(id[k],id[k<<1|1],inf,0); insert(id[k<<1|1],id[k],0,0);
}
void addedge(int k,int x,int y,int now)
{
if (l[k]==x&&r[k]==y)
{
insert(now,id[k],1,0); insert(id[k],now,0,0);
return;
}
int mid=l[k]+r[k]>>1;
if (y<=mid) addedge(k<<1,x,y,now);
else if (x>mid) addedge(k<<1|1,x,y,now);
else addedge(k<<1,x,mid,now),addedge(k<<1|1,mid+1,y,now);
}
inline bool spfa()
{
memset(dis,-1,sizeof(dis));
dis[S]=0; vis[S]=1; q[1]=S;
int t=0,w=1,x;
while (t!=w)
{
t=(t+1)%N;
x=q[t];
for (int i=head[x];i;i=next[i])
if (flow[i]&&dis[list[i]]<dis[x]+cost[i])
{
dis[list[i]]=dis[x]+cost[i];
path[list[i]]=i;
if (!vis[list[i]])
{
w=(w+1)%N;
q[w]=list[i];
vis[list[i]]=1;
}
}
vis[x]=0;
}
return dis[T]!=-1;
}
inline void mcf()
{
int x=inf;
for (int i=path[T];i;i=path[from[i]]) x=min(x,flow[i]);
for (int i=path[T];i;i=path[from[i]])
flow[i]-=x,flow[i^1]+=x,ans+=x*cost[i];
}
int main()
{
n=read(); S=0; T=30000;
build(1,1,5000);
for (int i=1;i<=n;i++)
{
int l=read(),r=read()-1,v=read();
insert(S,++num,1,v); insert(num,S,0,-v);
addedge(1,l,r,num);
}
while (spfa()) mcf();
cout << ans << endl;
return 0;
}

这个过程中流量都是自动分配的，我们考虑分配的优先级问题。

不妨按照ci排序，然后是裸的建图，跑匈牙利，每次匹配上就加入答案。

yzy大爷实测16s，我没有写代码。

然后还有lct1999神犇提供的随便贪心的作法。。

同样按照ci排序，然后从大到小将区间加入，并保证当前加入的区间是按右端点排序的，每次加入用并查集判一下是否冲突，如果冲突就删除。

6s

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
struct node {int l,r,c;} e[5005],q[5005];
int n,cnt,ans;
int f[5005];
inline int read()
{
int a=0,f=1; char c=getchar();
while (c<'0'||c>'9') {if (c=='-') f=-1; c=getchar();}
while (c>='0'&&c<='9') {a=a*10+c-'0'; c=getchar();}
return a*f;
}
inline bool cmp(node a,node b)
{
return a.c>b.c;
}
inline bool cmp0(node a,node b)
{
return a.r==b.r?a.l<b.l:a.r<b.r;
}
int find(int i)
{
return f[i]==i?i:f[i]=find(f[i]);
}
inline bool judge()
{
for (int i=1;i<=5000;i++) f[i]=i;
for (int i=1;i<=cnt;i++)
{
int p=find(q[i].l);
if (p>q[i].r) return 0;
f[p]=f[p+1];
}
return 1;
}
inline int insert(int x)
{
int i;
for (i=1;i<=cnt;i++)
if (cmp0(e[x],q[i])) break;
for (int j=cnt;j>=i;j--) q[j+1]=q[j];
q[i]=e[x]; cnt++;
return i;
}
inline void del(int x)
{
for (int i=x+1;i<=cnt;i++) q[i-1]=q[i];
cnt--;
}
int main()
{
n=read();
for (int i=1;i<=n;i++)
e[i].l=read(),e[i].r=read()-1,e[i].c=read();
sort(e+1,e+n+1,cmp);
for (int i=1;i<=n;i++)
{
int pos=insert(i);
if (!judge()) del(pos);
}
for (int i=1;i<=cnt;i++) ans+=q[i].c;
cout << ans << endl;
return 0;
}

至于那些20ms的就不知道什么黑科技了