[SDOI2011]拦截导弹

第一问：求一个需满足三个条件的最长不上升子序列的长度。

第二问：（求长度满足第一问的）每个点被包含的概率

解：

对每个点建len[2] fa[2]数组分别记录以该点开始/结束(后边会说)的LIS长度，fa表示这种len对应的方案数

第一问：dp方程 $ dp[i]=max(dp[j])+1 time_j<time_i ,h_j ge h_i ,v_j ge v_i $ 然后二维树状数组啊（空间不够）

三个条件->三维偏序->CDQ分治

定义h为第一维，time为第二维，v为第三维。

但是不同与以往的CDQ模板的套路。

由于我们要得到完整且正确的dp[i]，由方程知更新dp[i]时要用完整且正确的dp[j]，但不是一次就更新过来的（dp[i]多次被不同的dp[j]更新）。一句话就是转移要满足DAG的拓扑序。

为了保证完整且正确，我们采取以下CDQ顺序

1. 递归解决左区间
2. 用左区间更新右区间
3. 递归解决右区间

就能保证在更新右区间时左区间的dp[j]完整且正确（子问题解决）了，同时不难发现dp[mid+1]一定是完整且正确的了，因为他的入边都被转移，已经没有j能作为左区间来更新它了。

首先sort保证第一维单调，开始CDQ。

然后递归解决左区间。

接下来转移跨mid的部分，分别对左右区间以time为关键字sort，保证time的分别有序（以前都是用归并来递归解决，于是同样能保证左右区间分别有序，但由于这题CDQ的递归顺序，无法完成归并），然后对于[mid+1,r]用单调指针类似归并扫描[l,mid]，用树状数组维护第三维。

题目求的是最长不上升，但由于树状数组的特性不好维护，所以把h v全部倒序，这样h time v的单调性就统一了，转化为求最长不下降子序列。

正着一遍CDQ得到的len最大值是第一问的解。

第二问：

统计的前提条件是len[0]+len[1]-1==第一问答案，-1是除去重复计算的自己。不满足条件的点直接输出0.0......。

$某点的概率=frac {经过该点的LIS方案数} {总LIS方案数}$

$经过该点的LIS方案数=fa[0]*fa[1]$

总方案数用上一行的统计方式会算重，所以直接累加起始/结束点即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define db double
#define ll long long
#define reg register
#define F(i,a,b) for(register int (i)=(a);(i)<=(b);++(i))
using namespace std;
const int N=500100;
inline int read();
int mx,my;
int n,T;
int h_lsh[N],v_lsh[N],h_cnt,v_cnt;
bool mark[N];
struct BOOM{
    int tm,h,v;
    int len[2];
    db fa[2];
}f[N];//,q[N];
struct TR{
    int len;
    db fa;
    int _time;
    TR(){clear();}
    void clear(){len=0,fa=0.0,_time=0;}
}t[N];
inline bool cmp(BOOM a,BOOM b)
{
    if(a.h!=b.h) return a.h<b.h;
    if(a.tm!=b.tm) return a.tm<b.tm;
    return a.v<b.v;
}
inline bool cmp1(BOOM a,BOOM b)
{
    return a.tm<b.tm;
}
inline bool cmp2(BOOM a,BOOM b)
{
    return a.tm>b.tm;
}
void add(int v,int len,db fa)
{
    while(v<=v_cnt+23)
    {
        if(t[v]._time<T) t[v].clear(),t[v]._time=T;
        if(t[v].len==len) t[v].fa+=fa;
        else if(t[v].len<len)
        {
            t[v].len=len;
            t[v].fa=fa;
        }
        v+=(v&-v);
    }
}
void clear(int v)
{
    while(v<=v_cnt+23)
    {
        t[v].clear();
        v+=(v&-v);
    }
}
TR ask(int v)
{
    TR s;
    while(v)
    {
        if(t[v]._time<T) t[v].clear(),t[v]._time=T;
        if(s.len==t[v].len) s.fa+=t[v].fa;
        else if(s.len<t[v].len)
        {
            s.len=t[v].len;
            s.fa=t[v].fa;
        }
        v-=(v&-v);
    }
    return s;
}
void cdq(int l,int r,int o)
{
//    printf("L=%d R=%d
",l,r);
    if(l==r)
    {
    //    f[l].len[o]=f[l].fa[o]=1;
        return;
    }
    int mid=(l+r)>>1;
    cdq(l,mid,o);
    sort(f+l,f+mid+1,cmp1);
    sort(f+mid+1,f+r+1,cmp1);
    ++T;
    int p=l,pl=l,pr=mid+1;
    F(i,mid+1,r)
    {
        while(p<=mid&&f[p].tm<=f[i].tm)
        {
            add(f[p].v,f[p].len[o],f[p].fa[o]);
            ++p;
        }
        TR s=ask(f[i].v);
        ++s.len;
        if(s.len>f[i].len[o])
        {
            f[i].len[o]=s.len;
            f[i].fa[o]=s.fa;
        }
           else if(s.len==f[i].len[o])
           {
            f[i].fa[o]+=s.fa;
        }
    }
    sort(f+l,f+r+1,cmp);
    cdq(mid+1,r,o);
}
int main()
{
//    freopen("data.in","r",stdin);
    n=read();
    F(i,1,n)
    {
        f[i].h=h_lsh[i]=read();
        f[i].v=v_lsh[i]=read();
        f[i].len[0]=f[i].len[1]=f[i].fa[0]=f[i].fa[1]=1;
        f[i].tm=i;
    }
    sort(h_lsh+1,h_lsh+n+1);
    sort(v_lsh+1,v_lsh+n+1);
    h_cnt=unique(h_lsh+1,h_lsh+n+1)-h_lsh-1;
    v_cnt=unique(v_lsh+1,v_lsh+n+1)-v_lsh-1;
    F(i,1,n)
    {
        f[i].h=h_cnt+1-(lower_bound(h_lsh+1,h_lsh+h_cnt+1,f[i].h)-h_lsh);
        f[i].v=v_cnt+1-(lower_bound(v_lsh+1,v_lsh+v_cnt+1,f[i].v)-v_lsh);
//        printf("i=%d f[i].v=%d
",i,f[i].v);
    }
    sort(f+1,f+n+1,cmp);
//    F(i,1,n)
 //   {
//         printf("i=%d f[i].h=%d f[i].tm=%d f[i].v=%d
",i,f[i].h,f[i].tm,f[i].v);
//    }
    cdq(1,n,0);
    F(i,1,n)
    {
        f[i].h=h_cnt-f[i].h+1;
        f[i].v=v_cnt-f[i].v+1;
        f[i].tm=n-f[i].tm+1;
    }
    sort(f+1,f+n+1,cmp);
//    reverse(f+1,f+n+1);
    cdq(1,n,1);
    int pt_len=0;
    db tot=0.0;
    sort(f+1,f+n+1,cmp2);
    F(i,1,n)
    {
        pt_len=max(pt_len,f[i].len[0]);
 //       printf("%d
",f[i].len[0]);
    }
    F(i,1,n) if(f[i].len[0]==pt_len) tot+=f[i].fa[0];
    printf("%d
",pt_len);
    F(i,1,n)
    {
//        printf("i=%d 正：len=%d fa=%d 反：len=%d fa=%d bj=%d
",i,f[i].len[0],f[i].fa[0],f[i].len[1],f[i].fa[1],f[i].v);
        if(f[i].len[0]+f[i].len[1]-1==pt_len) printf("%.5lf ",f[i].fa[0]*f[i].fa[1]/(double)tot);
        else printf("%.5lf ",0.0);
    }
    return 0;
}
inline int read()
{
    int x=0;
    char tc=getchar();
    while(tc<'0'||tc>'9') tc=getchar();
    while(tc>='0'&&tc<='9') x=x*10+tc-48,tc=getchar();
    return x;
}