【BZOJ 3218】 3218: a + b Problem（最小割+可持久化线段树）

 

 

3218: a + b Problem

Time Limit: 20 Sec  Memory Limit: 40 MB
Submit: 1440  Solved: 545

Description

Input

Output

Sample Input

Sample Output

HINT

Source

【分析】

　　这题建图很神哦！

　　其实只是边的合并。

　　就是说，原本海陆型建图就好了的。

　　

　　但是这样有一点问题，就是pj只算一次的，但是这样跑算了很多次。

　　改一改图。

　　

　　这样就好了。

　　但是边很多。

　　一开始没注意那个l~r的，就觉得嗯，开一些辅助点合并一下边。

　　后来发现还有l~r的限制，其实也是开一些辅助点合并一下边，但是这里就有点高级了。

　　就是值考虑l<=a<=r的话就是开个权值线段树然后用线段树上的点作为辅助点。

　　但是还有一个条件是i<=j的时候才算，所以是可持久化线段树。

　　关于辅助点，其实上面的j‘就是辅助点，照着做就好了。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define Maxn 5010
#define Maxm 1000000000
// #define Maxm 10
#define INF 0x7fffffff
// #define LL long long

int mymin(int x,int y) {return x<y?x:y;}

struct node
{
    int x,y,f,o,next;
}t[Maxn*210];
int len,first[Maxn*40];

void ins(int x,int y,int f)
{
    if(y==0) return;
    t[++len].x=x;t[len].y=y;t[len].f=f;
    t[len].next=first[x];first[x]=len;t[len].o=len+1;
    t[++len].x=y;t[len].y=x;t[len].f=0;
    t[len].next=first[y];first[y]=len;t[len].o=len-1;
}

int dis[Maxn*40],st,ed;
queue<int > q;
bool bfs()
{
    memset(dis,-1,sizeof(dis));
    while(!q.empty()) q.pop();
    dis[st]=0;q.push(st);
    while(!q.empty())
    {
        int x=q.front();
        for(int i=first[x];i;i=t[i].next) if(t[i].f>0)
        {
            int y=t[i].y;
            if(dis[y]==-1)
            {
                dis[y]=dis[x]+1;
                q.push(y);
            }
        }
        q.pop();
    }
    if(dis[ed]==-1) return 0;
    return 1;
}

int ffind(int x,int flow)
{
    if(x==ed) return flow;
    int now=0;
    for(int i=first[x];i;i=t[i].next) if(t[i].f>0)
    {
        int y=t[i].y;
        if(dis[y]==dis[x]+1)
        {
            int a=ffind(y,mymin(flow-now,t[i].f));
            t[i].f-=a;
            t[t[i].o].f+=a;
            now+=a;
        }
        if(now==flow) break;
    }
    if(now==0) dis[x]=-1;
    return now;
}

int ans=0;
void max_flow()
{
    while(bfs())
    {
        ans-=ffind(st,INF);
    }
}
void output()
{
    for(int i=1;i<=len;i+=2)
    {
        printf("%d -> %d %d
",t[i].x,t[i].y,t[i].f);
    }printf("
");
}

int rt[Maxn],cnt;
struct nnode
{
    int lc,rc;
}tr[Maxn*40];


void add(int l,int r,int x,int y,int a,int id)
{
    ins(y,x,INF);
    ins(y,id,INF);
    if(l==r) return;
    int mid=(l+r)>>1;
    if(a<=mid)
    {
        tr[y].lc=++cnt;tr[y].rc=tr[x].rc;
        add(l,mid,tr[x].lc,tr[y].lc,a,id);
    }
    else
    {
        tr[y].rc=++cnt;tr[y].lc=tr[x].lc;
        add(mid+1,r,tr[x].rc,tr[y].rc,a,id);
    }
}

void add2(int l,int r,int x,int al,int ar,int id)
{
    if(l==al&&r==ar)
    {
        ins(id,x,INF);
        return;
    }
    int mid=(l+r)>>1;
    if(ar<=mid) add2(l,mid,tr[x].lc,al,ar,id);
    else if(al>mid) add2(mid+1,r,tr[x].rc,al,ar,id);
    else
    {
        add2(l,mid,tr[x].lc,al,mid,id);
        add2(mid+1,r,tr[x].rc,mid+1,ar,id);
    }
}


int main()
{
    int n;
    scanf("%d",&n);
    st=n*2+1,ed=st+1;cnt=ed;
    rt[0]=0;
    len=0;
    memset(first,0,sizeof(first));
    for(int i=1;i<=n;i++)
    {
        int a,b,c,w,al,ar,p;
        scanf("%d%d%d%d%d%d",&a,&b,&w,&al,&ar,&p);
        ans+=b+w;
        ins(st,i,b);ins(i,ed,w);
        ins(i,i+n,p);
        rt[i]=++cnt;
        add(0,Maxm,rt[i-1],rt[i],a,i);
        add2(0,Maxm,rt[i],al,ar,i+n);
    }
    // output();
    max_flow();
    printf("%d
",ans);
    return 0;
}

2017-04-06 22:05:14