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=;

 int N,a[MAXN],b[MAXN],c[MAXN],up,low=inf;
 struct edge{ int to,next,cap,flow,cost; }E[];
 int n,s,t,np=,first[],dist[],fl[];
 int mq[+],front,rear;
 bool inq[];
 void add_edge(int u,int v,int cap,int cost)
 {
     E[++np]=(edge){v,first[u],cap,,cost};
     first[u]=np;
     E[++np]=(edge){u,first[v],,,-cost};
     first[v]=np;
 }
 int MCMF(){
     int maxcost=,now;
     while(){
         memset(dist,,sizeof(dist));
         front=rear=;
         mq[rear++]=s,inq[s]=;
         while(front!=rear){
             int i=mq[front++]; if(front>) front=;
             inq[i]=;
             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]=;
                         if(rear>) rear=;
                     }
                 }
             }
         }
         if(dist[t]<=) break;
         now=t,maxcost+=dist[t];
         while(now!=s){
             E[fl[now]].flow++,E[(fl[now]-^)+].flow--;
             now=E[(fl[now]-^)+].to;
         }
     }
     return maxcost;
 }

 int rt=,np2=,lc[],rc[];
 void build(int &now,int L,int R){
     now=++np2;
     if(L==R){
         add_edge(now+N,t,,);
         return;
     }
     int m=L+R>>;
     build(lc[now],L,m);
     build(rc[now],m+,R);
     add_edge(now+N,lc[now]+N,inf,);
     add_edge(now+N,rc[now]+N,inf,);
 }
 void update(int now,int L,int R,int A,int B,int id){
     if(A<=L&&R<=B){
         add_edge(id,now+N,,);
         return;
     }
     int m=L+R>>;
     if(B<=m) update(lc[now],L,m,A,B,id);
     else if(A>m) update(rc[now],m+,R,A,B,id);
     else update(lc[now],L,m,A,B,id),update(rc[now],m+,R,A,B,id);
 }

 void _scanf(int &x)
 {
     x=;
     char ch=getchar();
     while(ch<''||ch>'') ch=getchar();
     while(ch>=''&&ch<='') x=x*+ch-'',ch=getchar();
 }
 void data_in()
 {
     _scanf(N);
     for(int i=;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=*(up-low)+N+,s=n-,t=n;
     build(rt,low,up-);
     for(int i=;i<=N;i++){
         update(rt,low,up-,a[i],b[i]-,i);
         add_edge(s,i,,c[i]);
     }
     printf("%d\n",MCMF());
 }
 int main()
 {
     data_in();
     work();
     return ;
 }