[ONTAK2015]Bajtman i Okrągły Robin

bzoj 4276: [ONTAK2015]Bajtman i Okrągły Robin

Time Limit: 40 Sec Memory Limit: 256 MB

Description

有n个强盗，其中第i个强盗会在[a[i],a[i]+1]，[a[i]+1,a[i]+2]，...，[b[i]-1,b[i]]这么多段长度为1时间中选出一个时间进行抢劫，并计划抢走c[i]元。作为保安，你在每一段长度为1的时间内最多只能制止一个强盗，那么你最多可以挽回多少损失呢？

Input

第一行包含一个正整数n(1<=n<=5000)，表示强盗的个数。
接下来n行，每行包含三个正整数a[i],b[i],c[i](1<=a[i]<b[i]<=5000,1<=c[i]<=10000)，依次描述每一个强盗。

Output

输出一个整数，即可以挽回的损失的最大值。

Sample Input

4

1 4 40

2 4 10

2 3 30

1 3 20

Sample Output

90

费用流
最容易想到的建图方法：



TLE
主要是因为一个强盗向一个区间内的所有点连边，太多了
所以我们考虑优化这些连边
线段树
建图方法：



然后跑最大费用即可

#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>
#define N 50001
#define M N*11
#define inf 1e9
using namespace std;
int n,a
,b
,c
,maxn;
int id[N*4],num,tot=1;
int src,dec,ans;
int front[N*6],from[M],next[M],to[M],cap[M],cost[M],pre[N*6];
int dis[N*6];
bool v[N*6];
int lc[N*6],rc[N*6];
queue<int>q;
struct node
{
int l,r;
}tr[N*4];
void add(int u,int v,int w,int val)
{
to[++tot]=v;next[tot]=front[u];front[u]=tot;from[tot]=u;cap[tot]=w;cost[tot]=val;
to[++tot]=u;next[tot]=front[v];front[v]=tot;from[tot]=v;cap[tot]=0;cost[tot]=-val;
}
void build(int k,int l,int r)
{
id[k]=++num;
tr[k].l=l;tr[k].r=r;
if(l==r) return;
int mid=l+r>>1;
build(k<<1,l,mid);
build((k<<1)+1,mid+1,r);
add(id[k<<1],id[k],mid-l+1,0);
add(id[(k<<1)+1],id[k],r-mid,0);
}
void insert(int k,int l,int r,int wh)
{
if(tr[k].l==l&&tr[k].r==r)
{
add(wh,id[k],1,c[wh-num]);
return;
}
int mid=tr[k].l+tr[k].r>>1;
if(r<=mid) insert(k<<1,l,r,wh);
else if(l>mid) insert((k<<1)+1,l,r,wh);
else {insert(k<<1,l,mid,wh);insert((k<<1)+1,mid+1,r,wh);}
}
bool spfa()
{
memset(dis,-127,sizeof(dis));
q.push(src);v[src]=true;dis[src]=0;
while(!q.empty())
{
int now=q.front();q.pop();v[now]=false;
for(int i=front[now];i;i=next[i])
{
int t=to[i];
if(dis[t]<dis[now]+cost[i]&&cap[i]>0)
{
dis[t]=dis[now]+cost[i];
pre[t]=i;
if(!v[t])
{
q.push(t);
v[t]=true;
}
}
}
}
return dis[dec]>0;
}
void mcmf()
{
while(spfa())
{
int tmp=inf;
for(int i=pre[dec];i;i=pre[from[i]]) tmp=min(tmp,cap[i]);
for(int i=pre[dec];i;i=pre[from[i]])
{
cap[i]-=tmp;cap[i^1]+=tmp;
}
ans+=tmp*dis[dec];
}
printf("%d",ans);
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c[i]);
b[i]--;
maxn=max(maxn,b[i]);
}
dec=n*6-1;
build(1,1,maxn);
for(int i=1;i<=n;i++)
add(src,num+i,1,0);
add(1,dec,maxn,0);
for(int i=1;i<=n;i++)
insert(1,a[i],b[i],i+num);
mcmf();
}

dis数组开始初始化为-1，应该是-inf，因为反向弧的费用为负值，未访问过的点要足够小才能完成回流