[BZOJ3218][UOJ#77]A+B Problem（可持久化线段树+最小割）

题目描述

传送门

题解

第一次见数据结构和网络流结合的题目
orz vfk

首先这题一眼最小割嘛
s->i,bi；i->t,wi
对每一个点i建立一个虚拟的点i’，i->i’,pi
然后如果li<=a(j)<=ri且1<=j<=i-1，那么连边i’->j,inf
跑最小割就行了
然而这道题边是$n^2$的，这样做不行

看到区间考虑用一棵线段树来优化边数
首先假设没有1<=j<=i-1的限制
先将ai,li,ri离散化，然后建立一棵权值线段树
如何连边？
线段树中的所有节点父亲->儿子,inf
所有叶子节点->ai=叶子节点的点i,inf
如果某一个点i的限制是[li,ri]，那么在线段树上查询，i->每一个查询到的区间,inf
相当于是最大限度地利用了权值
这种巧妙的方式将边数优化到了nlogn级别

然后现在加上了1<=j<=i-1这个限制
将线段树强行可持久化！
可持久化实际上就是不停地复制，那对于一个新建的点向旧点连边，容量inf

这样就做完了
orz ISA 现场a强不强

代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<queue>
using namespace std;
#define N 5005
#define inf 2100000000

int n,s,t,root,sz,sum,maxflow;
int a[N],b[N],w[N],l[N],r[N],p[N];
int LSH,lsh[N*3];
int tot,point[N*40],nxt[N*400],v[N*400],remain[N*400];
int deep[N*40],last[N*40],num[N*40],cur[N*40];
int ls[N*40],rs[N*40];
queue <int> q;

void addedge(int x,int y,int cap)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; remain[tot]=cap;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x; remain[tot]=0;
}
void bfs(int t)
{
    for (int i=1;i<=sz;++i) deep[i]=sz;
    deep[t]=0;
    for (int i=1;i<=sz;++i) cur[i]=point[i];
    while (!q.empty()) q.pop();
    q.push(t);
    while (!q.empty())
    {
        int now=q.front();q.pop();
        for (int i=point[now];i!=-1;i=nxt[i])
            if (deep[v[i]]==sz&&remain[i^1])
            {
                deep[v[i]]=deep[now]+1;
                q.push(v[i]);
            }
    }
}
int addflow(int s,int t)
{
    int now=t,ans=inf;
    while (now!=s)
    {
        ans=min(ans,remain[last[now]]);
        now=v[last[now]^1];
    }
    now=t;
    while (now!=s)
    {
        remain[last[now]]-=ans;
        remain[last[now]^1]+=ans;
        now=v[last[now]^1];
    }
    return ans;
}
void isap(int s,int t)
{
    bfs(t);
    for (int i=1;i<=sz;++i) ++num[deep[i]];

    int now=s;
    while (deep[s]<sz)
    {
        if (now==t)
        {
            maxflow+=addflow(s,t);
            now=s;
        }

        bool has_find=false;
        for (int i=cur[now];i!=-1;i=nxt[i])
            if (deep[v[i]]+1==deep[now]&&remain[i])
            {
                has_find=true;
                cur[now]=i;
                last[v[i]]=i;
                now=v[i];
                break;
            }

        if (!has_find)
        {
            int minn=sz-1;
            for (int i=point[now];i!=-1;i=nxt[i])
                if (remain[i]) minn=min(minn,deep[v[i]]);
            if (!(--num[deep[now]])) break;
            ++num[deep[now]=minn+1];
            cur[now]=point[now];
            if (now!=s) now=v[last[now]^1];
        }
    }
}
int find(int x)
{
    int l=1,r=LSH,mid,ans;
    while (l<=r)
    {
        mid=(l+r)>>1;
        if (lsh[mid]>=x) ans=mid,r=mid-1;
        else l=mid+1;
    }
    return ans;
}
void insert(int &now,int l,int r,int x,int id)
{
    int mid=(l+r)>>1;
    ls[++sz]=ls[now],rs[sz]=rs[now];
    if (l==r)
    {
        if (now) addedge(sz,now,inf);
        addedge(sz,id,inf);
        now=sz;
        return;
    }
    now=sz;
    if (l==r) return;
    if (x<=mid) insert(ls[now],l,mid,x,id);
    else insert(rs[now],mid+1,r,x,id);
}
void query(int now,int l,int r,int lr,int rr,int id)
{
    if (!now) return;
    int mid=(l+r)>>1;
    if (lr<=l&&r<=rr) {addedge(id,now,inf);return;}
    if (lr<=mid) query(ls[now],l,mid,lr,rr,id);
    if (mid+1<=rr) query(rs[now],mid+1,r,lr,rr,id);
}
int main()
{
    tot=-1;memset(point,-1,sizeof(point));
    scanf("%d",&n);
    for (int i=1;i<=n;++i)
    {
        scanf("%d%d%d%d%d%d",&a[i],&b[i],&w[i],&l[i],&r[i],&p[i]);
        sum+=b[i]+w[i];
        lsh[++LSH]=a[i],lsh[++LSH]=l[i],lsh[++LSH]=r[i];
    }
    sort(lsh+1,lsh+LSH+1);unique(lsh+1,lsh+LSH+1)-lsh-1;
    s=n+n+1,t=s+1;
    for (int i=1;i<=n;++i)
        addedge(s,i,b[i]),addedge(i,i+n,p[i]),addedge(i,t,w[i]);
    sz=t;
    for (int i=1;i<=n;++i)
    {
        a[i]=find(a[i]),l[i]=find(l[i]),r[i]=find(r[i]);
        query(root,1,LSH,l[i],r[i],i+n);
        insert(root,1,LSH,a[i],i);
    }
    for (int i=t+1;i<=sz;++i)
    {
        if (ls[i]) addedge(i,ls[i],inf);
        if (rs[i]) addedge(i,rs[i],inf);
    }
    isap(s,t);
    printf("%d\n",sum-maxflow);
}