bzoj2244 [SDOI2011]拦截导弹

传送门

这题其实没那么难，只是我做法麻烦所以调起来相当费事儿……这人没救了

第一问显然是裸的三维偏序，分治随便搞搞就行了。考虑第二问，答案其实就是包括它的子序列数除以总方案数，那么定义$g[i]$为以i结尾的子序列数量，$h[i]$为以i开头的子序列数量，包括它的子序列数就是$g[i]h[i]$了。

而$g[i],h[i]$的转移方程分别是：

\begin{align}g[i]=\sum_{j<i,a_j<a_i,f[j]=f[i]-1}g[j]\end{align}

\begin{align}g[i]=1(f[i]=1)\end{align}

\begin{align}h[i]=\sum_{i<j,a_i<a_j,f[i]=f[j]-1}h[j]\end{align}

\begin{align}h[i]=1(f[i]=\max_{j=1}^n{f[j]})\end{align}

(注：这里的$<$都是指满足题中的偏序关系)

不难看出这还是三维偏序的形式，再跑两遍分治即可。

三遍分治都是手打的，没有用复制粘贴，写了好久……超过200行的分治，真是醉了……

/**************************************************************
    Problem: 2244
    User: hzoier
    Language: C++
    Result: Accepted
    Time:4636 ms
    Memory:6368 kb
****************************************************************/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=50010;
struct A{
    int x,y,id;
    bool ins;
    bool operator<(const A &a)const{
        if(x!=a.x)return x<a.x;
        return ins&&!a.ins;
    }
}a[maxn],aa[maxn],b[maxn];
bool cmp(const A &a,const A &b){
    if(a.x!=b.x)return a.x>b.x;
    return a.ins&&!b.ins;
}
void CDQ1(int,int);
void CDQ2(int,int);
void CDQ3(int,int);
void add1(int,int);
void add2(int,long double);
int query1(int);
long double query2(int);
void clear1(int);
void clear2(int);
vector<int>vec[maxn];
long double c2[maxn]={0},g[maxn]={0},h[maxn]={0},tmp=0.0;
int n,t[maxn],f[maxn],c1[maxn],ans;
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&a[i].x,&a[i].y);
        t[i]=a[i].y;
        a[i].id=i;
        f[i]=1;
    }
    sort(t+1,t+n+1);
    for(int i=1;i<=n;i++)a[i].y=lower_bound(t+1,t+n+1,a[i].y)-t;
    copy(a+1,a+n+1,aa+1);
    CDQ1(1,n);
    for(int i=1;i<=n;i++){
        ans=max(ans,f[i]);
        vec[f[i]].push_back(i);
    }
    printf("%d\n",ans);
    for(int i=0;i<(int)vec[1].size();i++)g[vec[1][i]]=1.0;
    for(int k=2;k<=ans;k++){
        int i=0,j=0,cnt=0;
        while(i<(int)vec[k-1].size()&&j<(int)vec[k].size()){
            if(vec[k-1][i]<vec[k][j]){
                b[++cnt]=aa[vec[k-1][i]];
                b[cnt].ins=true;
                i++;
            }
            else{
                b[++cnt]=aa[vec[k][j]];
                b[cnt].ins=false;
                j++;
            }
        }
        while(i<(int)vec[k-1].size()){
            b[++cnt]=aa[vec[k-1][i]];
            b[cnt].ins=true;
            i++;
        }
        while(j<(int)vec[k].size()){
            b[++cnt]=aa[vec[k][j]];
            b[cnt].ins=false;
            j++;
        }
        CDQ2(1,cnt);
    }
    for(int i=0;i<(int)vec[ans].size();i++){
        tmp+=g[vec[ans][i]];
        h[vec[ans][i]]=1.0;
    }
    for(int k=ans-1;k;k--){
        int i=0,j=0,cnt=0;
        while(i<(int)vec[k+1].size()&&j<(int)vec[k].size()){
            if(vec[k+1][i]<vec[k][j]){
                b[++cnt]=aa[vec[k+1][i]];
                b[cnt].ins=true;
                i++;
            }
            else{
                b[++cnt]=aa[vec[k][j]];
                b[cnt].ins=false;
                j++;
            }
        }
        while(i<(int)vec[k+1].size()){
            b[++cnt]=aa[vec[k+1][i]];
            b[cnt].ins=true;
            i++;
        }
        while(j<(int)vec[k].size()){
            b[++cnt]=aa[vec[k][j]];
            b[cnt].ins=false;
            j++;
        }
        CDQ3(1,cnt);
    }
    for(int i=1;i<=n;i++)printf("%.10lf ",(double)(g[i]*h[i]/tmp));
    return 0;
}
void CDQ1(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ1(l,mid);
    copy(aa+l,aa+r+1,a+l);
    sort(a+l,a+mid+1,cmp);
    sort(a+mid+1,a+r+1,cmp);
    int i=l,j=mid+1;
    while(i<=mid&&j<=r){
        if(a[i].x>=a[j].x){
            add1(n-a[i].y+1,f[a[i].id]);
            i++;
        }
        else{
            f[a[j].id]=max(f[a[j].id],query1(n-a[j].y+1)+1);
            j++;
        }
    }
    while(j<=r){
        f[a[j].id]=max(f[a[j].id],query1(n-a[j].y+1)+1);
        j++;
    }
    for(i=l;i<=mid;i++)clear1(n-a[i].y+1);
    CDQ1(mid+1,r);
}
void CDQ2(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ2(l,mid);
    copy(b+l,b+r+1,a+l);
    sort(a+l,a+mid+1,cmp);
    sort(a+mid+1,a+r+1,cmp);
    int i=l,j=mid+1;
    while(i<=mid&&j<=r){
        if(a[i].x>a[j].x||(a[i].x==a[j].x&&a[i].ins)){
            if(a[i].ins)add2(n-a[i].y+1,g[a[i].id]);
            i++;
        }
        else{
            if(!a[j].ins)g[a[j].id]+=query2(n-a[j].y+1);
            j++;
        }
    }
    while(i<=mid){
        if(a[i].ins)add2(n-a[i].y+1,g[a[i].id]);
        i++;
    }
    while(j<=r){
        if(!a[j].ins)g[a[j].id]+=query2(n-a[j].y+1);
        j++;
    }
    for(i=l;i<=mid;i++)if(a[i].ins)clear2(n-a[i].y+1);
    CDQ2(mid+1,r);
}
void CDQ3(int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    CDQ3(mid+1,r);
    copy(b+l,b+r+1,a+l);
    sort(a+l,a+mid+1);
    sort(a+mid+1,a+r+1);
    int i=mid+1,j=l;
    while(i<=r&&j<=mid){
        if(a[i].x<a[j].x||(a[i].x==a[j].x&&a[i].ins)){
            if(a[i].ins)add2(a[i].y,h[a[i].id]);
            i++;
        }
        else{
            if(!a[j].ins)h[a[j].id]+=query2(a[j].y);
            j++;
        }
    }
    while(i<=r){
        if(a[i].ins)add2(a[i].y,h[a[i].id]);
        i++;
    }
    while(j<=mid){
        if(!a[j].ins)h[a[j].id]+=query2(a[j].y);
        j++;
    }
    for(int i=mid+1;i<=r;i++)if(a[i].ins)clear2(a[i].y);
    CDQ3(l,mid);
}
void add1(int x,int d){
    while(x<=n){
        c1[x]=max(c1[x],d);
        x+=x&-x;
    }
}
void add2(int x,long double d){
    while(x<=n){
        c2[x]+=d;
        x+=x&-x;
    }
}
int query1(int x){
    int ans=0;
    while(x){
        ans=max(ans,c1[x]);
        x&=x-1;
    }
    return ans;
}
long double query2(int x){
    long double ans=0.0;
    while(x){
        ans+=c2[x];
        x&=x-1;
    }
    return ans;
}
void clear1(int x){
    while(x<=n){
        c1[x]=0;
        x+=x&-x;
    }
}
void clear2(int x){
    while(x<=n){
        c2[x]=0.0;
        x+=x&-x;
    }
}

有一些做法可以一边分治一边求出$g$，然后再跑一遍分治就能求出$h$，可以减少代码量？听说lrd写的就是这个？表示还没理解清楚……