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

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

 

 

 

分析：

　　很容易看出来一个网络流的模型，但是暴力建图一点未来都没有......

　　注意到强盗出现的时间是一个连续的区间，于是可以用线段树来优化建图。（好操作啊！）

　　建图：
　　·源点S，汇点T。
　　·S向所有的小偷连边，容量为1，费用为c[i]。
　　·所有小偷向对应区间连边，容量为1，费用为0。
　　·线段树的叶子向T连边，容量为1，费用为0。
　　·线段树中的点向其左右儿子连边，容量为inf，费用为0。

　　最大流最大费就是答案。

　　But，卡常卡死我了......

　　注意两点（滑稽）：

　　1、为了小常数，以后网络流边的结构体不要定义from这个变量。

　　2、当你想要卡常的时候，注意不要用结构体去套你的算法......全部东西都用数组吧......

　　3、我也不知道为什么本机上最快的数组版本上去就T了？所以还是把过了的那个弄上来吧......

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<cctype>
#define inf 1e9
using namespace std;
const int MAXN=5005;
 
int N,a[MAXN],b[MAXN],c[MAXN],up,low=inf;
struct edge{ int to,next,cap,flow,cost; }E[300005];
int n,s,t,np=0,first[15005],dist[15005],fl[15005];
int mq[15005+5],front,rear;
bool inq[15005];
void add_edge(int u,int v,int cap,int cost)
{
    E[++np]=(edge){v,first[u],cap,0,cost};
    first[u]=np;
    E[++np]=(edge){u,first[v],0,0,-cost};
    first[v]=np;
}
int MCMF(){
    int maxcost=0,now;
    while(1){
        memset(dist,0,sizeof(dist));
        front=rear=0;
        mq[rear++]=s,inq[s]=1;
        while(front!=rear){
            int i=mq[front++]; if(front>15005) front=0;
            inq[i]=0;
            for(int p=first[i];p;p=E[p].next){
                int j=E[p].to;
                if(E[p].cap>E[p].flow&&dist[i]+E[p].cost>dist[j]){
                    dist[j]=dist[i]+E[p].cost;
                    fl[j]=p;
                    if(!inq[j]){
                        mq[rear++]=j,inq[j]=1;
                        if(rear>15005) rear=0;
                    }
                }
            }
        }
        if(dist[t]<=0) break;
        now=t,maxcost+=dist[t];
        while(now!=s){
            E[fl[now]].flow++,E[(fl[now]-1^1)+1].flow--;
            now=E[(fl[now]-1^1)+1].to;
        }
    }
    return maxcost;
}
     
int rt=0,np2=0,lc[10005],rc[10005];
void build(int &now,int L,int R){
    now=++np2;
    if(L==R){
        add_edge(now+N,t,1,0);
        return;
    }
    int m=L+R>>1;
    build(lc[now],L,m);
    build(rc[now],m+1,R);
    add_edge(now+N,lc[now]+N,inf,0);
    add_edge(now+N,rc[now]+N,inf,0);
}
void update(int now,int L,int R,int A,int B,int id){
    if(A<=L&&R<=B){
        add_edge(id,now+N,1,0);
        return;
    }
    int m=L+R>>1;
    if(B<=m) update(lc[now],L,m,A,B,id);
    else if(A>m) update(rc[now],m+1,R,A,B,id);
    else update(lc[now],L,m,A,B,id),update(rc[now],m+1,R,A,B,id);
}
 
void _scanf(int &x)
{
    x=0;
    char ch=getchar();
    while(ch<'0'||ch>'9') ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
}
void data_in()
{
    _scanf(N);
    for(int i=1;i<=N;i++){
        _scanf(a[i]);_scanf(b[i]);_scanf(c[i]);
        up=max(up,b[i]),low=min(low,a[i]);
    }
}
void work()
{
    n=2*(up-low)+N+5,s=n-1,t=n;
    build(rt,low,up-1);
    for(int i=1;i<=N;i++){
        update(rt,low,up-1,a[i],b[i]-1,i);
        add_edge(s,i,1,c[i]);
    }
    printf("%d\n",MCMF());
}
int main()
{
    data_in();
    work();
    return 0;
}