bzoj4276 [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的时间内最多只能制止一个强盗，那么你最多可以挽回多少损失呢？

1<=n<=5000
1<=a[i]

Solution

---

很裸的费用流模型，每个强盗向所有区间连边即可
然鹅这样直接建图会挂，考虑用线段树优化建图，每个强盗向所在区间连边，然后就1A了

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>

#define rep(i,st,ed) for (int i=st;i<=ed;++i)
#define fill(x,t) memset(x,t,sizeof(x))

const int INF=0x3f3f3f3f;
const int N=100005;
const int E=525005;

struct edge {int x,y,w,c,next;} e[E];

std:: queue <int> que;

int dis[N*2+1],pre[N*2+1],lim;
int ls[N*2+1],edCnt=1;
int a[N*2+1],b[N*2+1],c[N*2+1];

bool vis[N];

int read() {
    int x=0,v=1; char ch=getchar();
    for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
    for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
    return x*v;
}

void add_edge(int x,int y,int w,int c) {
    e[++edCnt]=(edge) {x,y,w,c,ls[x]}; ls[x]=edCnt;
    e[++edCnt]=(edge) {y,x,0,-c,ls[y]}; ls[y]=edCnt;
}

bool spfa(int st,int ed) {
    for (;!que.empty();) que.pop();
    que.push(st); vis[st]=1;
    fill(dis,-31); int inf=dis[st]; dis[st]=0;
    for (;!que.empty();) {
        int now=que.front(); que.pop();
        for (int i=ls[now];i;i=e[i].next) {
            if (e[i].w>0&&dis[now]+e[i].c>dis[e[i].y]) {
                dis[e[i].y]=dis[now]+e[i].c;
                pre[e[i].y]=i;
                if (vis[e[i].y]) continue;
                que.push(e[i].y);
                vis[e[i].y]=1;
            }
        }
        vis[now]=0;
    }
    return dis[ed]!=inf;
}

int modify(int ed) {
    int mn=INF;
    for (int i=ed;pre[i];i=e[pre[i]].x) {
        mn=std:: min(mn,e[pre[i]].w);
    }
    for (int i=ed;pre[i];i=e[pre[i]].x) {
        e[pre[i]].w-=mn;
        e[pre[i]^1].w+=mn;
    }
    return mn*dis[ed];
}

int mcf(int st,int ed) {
    int ret=0;
    for (;spfa(st,ed);) ret+=modify(ed);
    return ret;
}

void ins(int now,int tl,int tr,int l,int r,int x,int w,int c) {
    if (tl==l&&tr==r) {
        add_edge(x,now,w,c);
        return ;
    }
    int mid=(tl+tr)>>1;
    if (r<=mid) ins(now<<1,tl,mid,l,r,x,w,c);
    else if (l>mid) ins(now<<1|1,mid+1,tr,l,r,x,w,c);
    else {
        ins(now<<1,tl,mid,l,mid,x,w,c);
        ins(now<<1|1,mid+1,tr,mid+1,r,x,w,c);
    }
}

void build_tree(int now,int tl,int tr) {
    if (tl==tr) {
        add_edge(now,N,1,0);
        lim=std:: max(lim,now);
        return ;
    }
    int mid=(tl+tr)>>1;
    add_edge(now,now<<1,INF,0);
    add_edge(now,now<<1|1,INF,0);
    build_tree(now<<1,tl,mid);
    build_tree(now<<1|1,mid+1,tr);
}

int main(void) {
    int n=read();
    build_tree(1,1,5000);
    rep(i,1,n) a[i]=read(),b[i]=read(),c[i]=read();
    rep(i,1,n) add_edge(0,i+lim,1,c[i]);
    rep(i,1,n) {
        ins(1,1,5000,a[i],b[i]-1,i+lim,1,0);
    }
    printf("%d\n", mcf(0,N));
    return 0;
}