Bzoj2244 [SDOI2011]拦截导弹

Time Limit: 30 Sec  Memory Limit: 512 MBSec  Special Judge
Submit: 561  Solved: 228

Description

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度、并且能够拦截任意速度的导弹，但是以后每一发炮弹都不能高于前一发的高度，其拦截的导弹的飞行速度也不能大于前一发。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

在不能拦截所有的导弹的情况下，我们当然要选择使国家损失最小、也就是拦截导弹的数量最多的方案。但是拦截导弹数量的最多的方案有可能有多个，如果有多个最优方案，那么我们会随机选取一个作为最终的拦截导弹行动蓝图。

我方间谍已经获取了所有敌军导弹的高度和速度，你的任务是计算出在执行上述决策时，每枚导弹被拦截掉的概率。

Input

第一行包含一个正整数n，表示敌军导弹数量；

下面 行按顺序给出了敌军所有导弹信息：

第i+1行包含2个正整数h_i和v_i，分别表示第 枚导弹的高度和速度。

 

Output

输出包含两行。

第一行为一个正整数，表示最多能拦截掉的导弹数量；

第二行包含n个0到1之间的实数，第i个数字表示第i枚导弹被拦截掉的概率（你可以保留任意多位有效数字）。

 

Sample Input

4

3 30

4 40

6 60

3 30

Sample Output

2

0.33333 0.33333 0.33333 1.00000

【数据规模和约定】


对于100%的数据，1≤n≤5*104， 1≤hi ，vi≤109；

均匀分布着约30%的数据，所有vi均相等。

均匀分布着约50%的数据，满足1≤hi ，vi≤1000。

HINT

鸣谢kac提供sj程序！

Source

第一轮day2

CDQ分治 DP

就是因为导弹拦截系统毛病都这么多，我推COD9的时候才会打出来BAD END

传说这叫三维偏序问题（求三个维度上都单调的序列）

如果一颗导弹在最长序列上，那么包含它的最长序列数量/所有的最长序列数量 就是它被拦截掉的概率

先把高度和速度都离散化。

用CDQ分治除掉时间维度，分治过程中排序除掉高度，然后用树状数组求LIC←（为了能用树状数组，首先要将速度逆序，把单调降转化成单调升）

然后将所有数组逆序，再用CDQ分治求一遍最长单调序列。

处理每一颗导弹，如果它前面的最长序列长度+它后面的最长序列长度（当然是包含它自身的序列）+自身的1 ==最长单调不升序列长度，那么它在(前面的方案数*后面的方案数)个最长序列上。

好麻烦好麻烦

掏出了先前的CDQ分治模板一点点写，终于搞定了。

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int mxn=50021;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct BIT{
    int f;
    double w;
    BIT(){f=0,w=0;}
}t[mxn];
int n;
int st[mxn],top=0;
void add(int p,int f,double w){
    while(p<n){
        if(t[p].f<f){
            if(t[p].f==0)st[++top]=p;
            t[p].f=f;t[p].w=w;
        }
        else if(t[p].f==f) t[p].w+=w;
        p+=p&-p;
    }
    return;
}
BIT ask(int p){
    BIT res;
    while(p){
        if(t[p].f>res.f) res=t[p];
        else if(t[p].f==res.f) res.w+=t[p].w;
        p-=p&-p;
    }
    return res;
}
//
struct Dan{
    int h,v;
    int f[2];
    double g[2];//正/反 最长长度 对应方案数 
    int id,t;
}a[mxn],q[mxn];
int wh[mxn],wv[mxn],id[mxn];
int rk[mxn];
int cmp(int i,int j){
    return a[i].h<a[j].h || (a[i].h==a[j].h && a[i].id<a[j].id);
}
int cmpid(Dan a,Dan b){return a.id<b.id;}
//
int cnt=0;
void solve(int l,int r,int mode){
    if(l==r){
        if(a[l].f[mode]<1){a[l].f[mode]=1;a[l].g[mode]=1;}
        return;
    }
    int mid=(l+r)>>1,i,j;
    memcpy(q+l,a+l,sizeof(Dan)*(r-l+1));
    int q1=l,q2=mid+1;
    for(i=l;i<=r;i++){//按高度划分 
        if(q[i].t<=mid)a[q1++]=q[i];     else a[q2++]=q[i];
    }
    solve(l,mid,mode);
    q1=l;
    for(i=mid+1;i<=r;i++){
        while(q1<=mid && a[q1].id<a[i].id) add(a[q1].v,a[q1].f[mode],a[q1].g[mode]),q1++;
        BIT res=ask(a[i].v);
        if(!res.f)continue;
//      printf("!! %d   %.3f
",res.f,res.w);
        if(res.f+1>a[i].f[mode]){
            a[i].f[mode]=res.f+1;
            a[i].g[mode]=res.w;
        }
        else if(res.f+1==a[i].f[mode]) a[i].g[mode]+=res.w;
    }
//  for(i=1;i<=n;i++) t[i].w=0,t[i].f=0;//可优化 
    while(top){t[st[top]].w=0;t[st[top--]].f=0;}
    solve(mid+1,r,mode);
    merge(a+l,a+mid+1,a+mid+1,a+r+1,q+l,cmpid);//
    memcpy(a+l,q+l,sizeof(Dan)*(r-l+1));//还原 
    return;
}
int th,tv=0;
int main(){
//  freopen("in.txt","r",stdin);
    int i,j;
    n=read();
    for(i=1;i<=n;i++){
        a[i].h=read();a[i].v=read();a[i].id=i;
        wh[i]=a[i].h;wv[i]=a[i].v;
        rk[i]=i;
    }
    sort(wh+1,wh+n+1);
    sort(wv+1,wv+n+1);
    th=unique(wh+1,wh+n+1)-wh-1;
    tv=unique(wv+1,wv+n+1)-wv-1;
    for(i=1;i<=n;i++){//离散化 倒序 
        a[i].h=th-(lower_bound(wh+1,wh+th+1,a[i].h)-wh)+1;
        a[i].v=tv-(lower_bound(wv+1,wv+tv+1,a[i].v)-wv)+1;
    }
    sort(rk+1,rk+n+1,cmp);
    for(i=1;i<=n;i++) a[rk[i]].t=i;
    solve(1,n,0);
    for(i=1;i<=n;i++){
        a[i].h=th-a[i].h+1;
        a[i].v=tv-a[i].v+1;
        a[i].id=n-a[i].id+1;
        a[i].t=n-a[i].t+1;
    }
    reverse(a+1,a+n+1);
//  sort(rk+1,rk+n+1,cmp);
    solve(1,n,1);
    reverse(a+1,a+n+1);
    double smm=0;int ans=0;
    for(register int i=1;i<=n;i++){
        if(a[i].f[0]+a[i].f[1]-1>ans){ans=a[i].f[0]+a[i].f[1]-1;}
    }
    printf("%d
",ans);
    for(i=1;i<=n;i++){
        if(a[i].f[0]==ans){
            smm+=a[i].g[0]*a[i].g[1];
        }
    }
    for(i=1;i<=n;i++){
        double res=a[i].g[0]*a[i].g[1];
        if(a[i].f[0]+a[i].f[1]-1!=ans)printf("0 ");
        else printf("%.5f ",res/smm);
    }
    return 0;
}