[bzoj4276][ONTAK2015]Bajtman i Okrągły Robin

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

Time Limit: 40 Sec Memory Limit: 256 MB
Submit: 77 Solved: 39
[Submit][Status][Discuss]
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],ci，依次描述每一个强盗。
Output

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

4

1 4 40

2 4 10

2 3 30

1 3 20
Sample Output

90

题解：
首先很明显的可以看出来个可以跑费用流，可以建两排点，一排是所有的人，一排是时间min-max。我们从源点向每个人连<1,0>的边，从每个人向他们的时间连<1,c[i]>的边，从每个时间向汇点连<1,0>的边。然后跑费用流就行。
但是上面的这种方法的点有n*2+2个，边是n^2级别的，显然不行。那这样我们就需要优化一下。
其实每个人所能作案的时间是一个时间段也就是一个区间，那么我们能不能将这个时间段划分成几个小的来连边，这样就减少了边的数量。这样我们就想到了线段树可以将区间裂开。
所以我们以所有输入的区间的最小值和最大值建一棵线段树。
从源点向每个人连<1,c[i]>的边。
从线段树的每个父亲节点向他的子节点连

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define T 2
#define inf 0x7fffffff
const int N=5010;
const int M=100000;
bool f[M];
struct S{int st,en,va,co;}aa[M*20];
int n,a[N],b[N],c[N],tot=1,point[M],next[M*20],dis[M],pre[M],l[M*20];
inline int in(){
    int x=0;char ch=getchar();
    while(ch<'0'||ch>'9') ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x;
}
inline void add(int x,int y,int va,int co){
    tot+=1;next[tot]=point[x];point[x]=tot;
    aa[tot].st=x;aa[tot].en=y;aa[tot].va=va;aa[tot].co=co;
    tot+=1;next[tot]=point[y];point[y]=tot;
    aa[tot].st=y;aa[tot].en=x;aa[tot].va=0;aa[tot].co=-co;
}
#define mid (l+r)/2
#define L k<<1,l,mid
#define R k<<1|1,mid+1,r
inline void build_1(int k,int l,int r){
    if(l==r){
        add(k+2+n,T,1,0);
        return ;
    }
    add(n+2+k,n+2+(k<<1),inf,0);
    add(n+2+k,n+2+(k<<1|1),inf,0);
    build_1(L); build_1(R);
}
inline void build_2(int k,int l,int r,int x,int y,int z){
    if(x<=l&&y>=r){
        add(z+2,n+2+k,inf,0);
        return ;
    }
    if(x<=mid) build_2(L,x,y,z);
    if(y>mid) build_2(R,x,y,z);
}
inline int SPFA(int x,int y){
    int i,u,h,t;
    memset(f,1,sizeof(f));
    memset(pre,0,sizeof(pre));
    for(i=1;i<=M;++i) dis[i]=-1;
    h=t=1;l[h]=x;dis[x]=0;
    while(h<=t){
        u=l[h]; f[u]=true;
        for(i=point[u];i;i=next[i])
          if(aa[i].va&&dis[aa[i].en]<dis[u]+aa[i].co){
            dis[aa[i].en]=dis[u]+aa[i].co;
            pre[aa[i].en]=i;
            if(f[aa[i].en]){
                f[aa[i].en]=false;
                if(dis[aa[i].en]>dis[l[h+1]]) l[h--]=aa[i].en;
                else l[++t]=aa[i].en;
            }
          }
        h+=1;
    }
    return dis[y];
}
inline int ISAP(int x,int y){
    int i,minn=inf;
    for(i=y;i!=x;i=aa[pre[i]].st)
      minn=min(minn,aa[pre[i]].va);
    for(i=y;i!=x;i=aa[pre[i]].st){
        aa[pre[i]].va-=minn;
        aa[pre[i]^1].va+=minn;
    }
    return minn;
}
int main(){
    int i,j,r=0,l=inf;
    n=in();
    for(i=1;i<=n;++i){
        a[i]=in();b[i]=in();c[i]=in();
        b[i]-=1;
        r=max(r,b[i]);
        l=min(l,a[i]);
    }
    build_1(1,l,r);
    for(i=1;i<=n;++i){
        add(1,i+2,1,c[i]);
        build_2(1,l,r,a[i],b[i],i);
    } 
    int minn,ans=0;
    while(minn!=-1){
        minn=SPFA(1,T);
        if(minn!=-1) ans+=minn*ISAP(1,T);
    }
    printf("%d\n",ans);
}