bzoj 2244 [SDOI2011]拦截导弹（DP+CDQ分治+BIT）

 

【题目链接】

 

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

 

【题意】

 

    给定n个二元组，求出最长不上升子序列和各颗导弹被拦截的概率。

 

【思路】

 

    DP+CDQ分治+BIT

    先把序列反转一下，lis求起来方便。

    对于第一问，我们要求的是

        f[i]=max{ f[j] },j<i,x[j]<x[i],y[j]<y[i]

    发现需要满足的条件就是一个三维偏序，可以用CDQ分治求解

    不难发现第二问其实就等于：一颗导弹所在的lis数/总的lis数。一个导弹所在的lis必须包含自己，所以我们设g[i]表示以i为结尾的lis总数，则有转移式：

        g[i]=sigma{ g[j] }, j<i,x[j]<x[i],y[j]<y[i],f[j]+1=f[i]

    依旧可以用CDQ分治求。注意到最后的一个f的关系，这时候只需要统计出之前的最大lis值再与f相比较就可以了（蒟蒻的我一直苦思冥想。。。

    相似的可以求出g’f’。都是g f的相反定义，即以i开头的…

    奇技淫巧:我们可以在反转一下并对序列取一下反，这样就都可以套用函数辣。貌似离散化之后跑得飞快，一跃直上rk3

 

【代码】

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define FOR(a,b,c) for(int a=b;a<=c;a++)
using namespace std;

const int N = 1e5+10;

struct Node {
    int id,x,y;
    bool operator<(const Node& rhs)const {
        return x<rhs.x||(x==rhs.x&&y<rhs.y);
    }
}q[N],t[N];
bool cmp(const Node& a,const Node& b)
{
    return a.id<b.id;
}

int f[2][N]; double g[2][N],ans[N];
int hash[N],tot,n;


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

int t_f[N],tag[N],T; double t_g[N];
void add(int x,int f,double g)
{
    for(;x<=tot;x+=x&-x) {
        if(tag[x]!=T) {tag[x]=T;t_f[x]=0;t_g[x]=0;}
        if(f>t_f[x]){t_f[x]=f;t_g[x]=g;}
        else if(f==t_f[x]) t_g[x]+=g;
    }
}
void query(int x,int& mx,double& sum)
{
    mx=0; sum=0.0;
    for(;x;x-=x&-x) if(tag[x]==T){
        if(t_f[x]>mx) {
            mx=t_f[x]; sum=t_g[x];
        } else if(t_f[x]==mx)
            sum+=t_g[x];
    }
}

void solve(int l,int r,int ty)
{
    if(l==r) {
        if(!f[ty][l]){
            f[ty][l]=1; g[ty][l]=1;
        }
        return ;
    }
    int mid=(l+r)>>1;
    int l1=l,l2=mid+1,i,j,cnt=0;
    for(i=l;i<=r;i++) {
        if(q[i].id<=mid) t[l1++]=q[i];
        else t[l2++]=q[i];
    }
    memcpy(q+l,t+l,sizeof(Node)*(r-l+1));
    solve(l,mid,ty);
    T++;
    sort(q+mid+1,q+r+1);
    for(i=mid+1,j=l;i<=r;i++)
    {
        int id;
        for(;j<=mid&&q[j].x<=q[i].x;j++) {
            id=q[j].id; cnt++;
            add(q[j].y,f[ty][id],g[ty][id]);
        }
        int mx; double sum;
        query(q[i].y,mx,sum);
        id=q[i].id;
        if(mx>0) {
            if(mx+1>f[ty][id]) {
                f[ty][id]=mx+1; g[ty][id]=sum;
            } else if(mx+1==f[ty][id]) {
                g[ty][id]+=sum;
            }
        }
    }
    solve(mid+1,r,ty);
    l1=l,l2=mid+1; int now=l;
    while(l1<=mid||l2<=r) {
        if(l2>r||l1<=mid&&q[l1]<q[l2]) t[now++]=q[l1++];
        else t[now++]=q[l2++];
    }
    memcpy(q+l,t+l,sizeof(Node)*(r-l+1));
}

int main()
{
    //freopen("in.in","r",stdin);
    //freopen("out.out","w",stdout);
    n=read();
    int mxx=0;
    FOR(i,1,n)
    {
        q[i].x=read(),q[i].y=read();
        hash[i]=q[i].y;
        mxx=max(mxx,q[i].x);
    }
    sort(hash+1,hash+n+1);
    tot=unique(hash+1,hash+n+1)-hash-1;
    FOR(i,1,n)
        q[i].y=lower_bound(hash+1,hash+tot+1,q[i].y)-hash;
    reverse(q+1,q+n+1);
    FOR(i,1,n) q[i].id=i;
    solve(1,n,0);

    sort(q+1,q+n+1,cmp);
    reverse(q+1,q+n+1);
    FOR(i,1,n)
        q[i].x=mxx-q[i].x+1,q[i].y=tot-q[i].y+1,
        q[i].id=i;
    solve(1,n,1);
    int mx=0; double sum=0;
    FOR(i,1,n) {
        int tmp=f[0][i];
        if(tmp>mx) {
            mx=tmp; sum=g[0][i]*g[1][n-i+1];
        } else if(tmp==mx)
            sum+=g[0][i]*g[1][n-i+1];
    }
    printf("%d\n",mx);
    for(int i=n;i;i--) {
        if(f[0][i]+f[1][n-i+1]-1==mx) {
            ans[i]=(g[0][i]*g[1][n-i+1])/sum;
        } else ans[i]=0;
    }
    for(int i=n;i>1;i--) printf("%.5lf ",ans[i]);
    printf("%.5lf",ans[1]);
    return 0;
}