bzoj 3218 a + b Problem（最小割+主席树）

【题目链接】

    http://www.lydsy.com/JudgeOnline/problem.php?id=3218

【题意】

    给n个格子涂白或黑色，白则wi，黑则bi的好看度，若黑格i存在：

        1<=j<I,li<=aj<=ri,格子为白色

    则损失pi，问最大的好看度。

【思路】

    考虑建立最小割模型:

1. 首先将一个点拆成两个中间连pi
2. 连边(S,Xi,wi) (Xi,T,bi)
3. 对于一个满足i要求的j，连边(Xj,Yi,inf)，代表i只有两种选择，一为设白色，一为损失pi。

　 这样跑出的最小割即为答案。

　 但该图的边数过多，因此需要优化。

　 建一棵线段树，由线段树中所有被[li,ri]包含的点向Yi连边inf，由Xi向对应的叶子连边。然后加上j<i的条件，我们需要一棵可持久化线段树，因此需要Yi被T[i-1]的[li,ri]区间连边，Xi向T[i]的叶子连边。这样就成功将边数缩到O(nlogn)级别。

【代码】

#include<set>
#include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define X(i) (i)
#define Y(i) (i+n)
#define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
#define FOR(a,b,c) for(int a=(b);a<=(c);a++)
using namespace std;

typedef long long ll;
const int N = 2e5+200;
const int inf = 1e9;

ll read() {
    char c=getchar();
    ll f=1,x=0;
    while(!isdigit(c)) {
        if(c=='-') f=-1; c=getchar();
    }
    while(isdigit(c))
        x=x*10+c-'0',c=getchar();
    return x*f;
}

struct Edge {
    int u,v,cap,flow;
};
struct Dinic {
    int d[N],cur[N],vis[N];
    vector<Edge> es;
    vector<int> g[N];
    queue<int> q;
    
    void AddEdge (int u,int v,int w) {
        es.push_back((Edge){u,v,w,0});
        es.push_back((Edge){v,u,0,0});
        int m=es.size();
        g[u].push_back(m-2);
        g[v].push_back(m-1);
    }
    bool bfs(int s,int t) {
        memset(vis,0,sizeof(vis));
        d[s]=0; vis[s]=1;
        q.push(s);
        while(!q.empty()) {
            int u=q.front(); q.pop();
            FOR(i,0,(int)g[u].size()-1) {
                Edge& e=es[g[u][i]];
                int v=e.v;
                if(e.cap>e.flow&&!vis[v]) {
                    vis[v]=1;
                    d[v]=d[u]+1;
                    q.push(v);
                }
            }
        }
        return vis[t];
    }
    int dfs(int u,int a,int t) {
        if(u==t||a==0) return a;
        int flow=0,f;
        for(int& i=cur[u];i<g[u].size();i++) {
            Edge& e=es[g[u][i]];
            int v=e.v;
            if(d[v]==d[u]+1&&(f=dfs(v,min(a,e.cap-e.flow),t))>0) {
                e.flow+=f;
                es[g[u][i]^1].flow-=f;
                flow+=f,a-=f;
                if(!a) break;
            }
        }
        return flow;
    }
    int maxflow(int s,int t) {
        int flow=0;
        while(bfs(s,t)) {
            memset(cur,0,sizeof(cur));
            flow+=dfs(s,inf,t);
        }
        return flow;
    }
} dc;

int n,cnt;

struct Tnode {
    Tnode *ls,*rs;
    int sum,id;
    void * operator new (size_t,Tnode* l,Tnode* r) {
        static Tnode mempool[N],*G=mempool;
        G->ls=l,G->rs=r,G->id=++cnt;
        return G++;
    }
    Tnode* build(int l,int r,int x,int from) {
        int mid=l+r>>1;
        Tnode *t;
        if(l==r)
            t=new (0x0,0x0)Tnode;
        else if(x<=mid)
            t=new (ls->build(l,mid,x,from),rs) Tnode;
        else 
            t=new (ls,rs->build(mid+1,r,x,from)) Tnode;
        dc.AddEdge(from,t->id,inf);
        dc.AddEdge(id,t->id,inf);
        return t;
    }
    void Add(int l,int r,int L,int R,int to) {
        if(L<=l&&r<=R) {
            dc.AddEdge(id,to,inf);
        } else {
            int mid=l+r>>1;
            if(L<=mid&&ls) ls->Add(l,mid,L,R,to);
            if(mid<R&&rs) rs->Add(mid+1,r,L,R,to);
        }
    }
    
} *T[5050];

int hash[N],tot,a[N],b[N],l[N],r[N],p[N],w[N];

int main()
{
    n=read();
    cnt=Y(n);
    int s=++cnt,t=++cnt;
    T[0]=new (0x0,0x0)Tnode;
    T[0]->ls=T[0]->rs=T[0];
    ll ans=0;
    FOR(i,1,n) {
        a[i]=read(),b[i]=read(),w[i]=read(),l[i]=read(),r[i]=read(),p[i]=read();
        hash[++tot]=a[i],hash[++tot]=l[i],hash[++tot]=r[i];
    }
    
    sort(hash+1,hash+tot+1);
    tot=unique(hash+1,hash+tot+1)-hash-1;
    FOR(i,1,n) {
        a[i]=lower_bound(hash+1,hash+tot+1,a[i])-hash;
        l[i]=lower_bound(hash+1,hash+tot+1,l[i])-hash;
        r[i]=lower_bound(hash+1,hash+tot+1,r[i])-hash;
    }
    
    FOR(i,1,n) {
        ans+=w[i]+b[i];
        dc.AddEdge(s,X(i),w[i]);
        dc.AddEdge(X(i),t,b[i]);
        T[i]=T[i-1]->build(1,tot,a[i],X(i));
        T[i-1]->Add(1,tot,l[i],r[i],Y(i));
        dc.AddEdge(Y(i),X(i),p[i]);
    }
    ans-=dc.maxflow(s,t);
    printf("%lld
",ans);
    return 0;
}

P.S.神的我无力吐槽=-=