[考试反思]0402省选模拟60：空白

一上午又跟划水一样。一个暴力两个空题。

部分分又少又难写，真心难受的一场考试。

空题倒不是不会，但是分别只会$15,10$分的档。于是博了博信仰尝试冲正解。

然而当然什么都没有冲出来。

也一直在弄$T1$想尝试$n^2$过五万或十万那样，然而依旧没卡过去。

然后就惨成这样了。。。。。。

也是状态不太好。冲$T3$其实差不多应该能想到，还是把太多时间放到$T1,2$上了。

改题比较顺利。也许吧。今天可能是最后一次能学$OI$到这个时候了/

T1：摧毁图状数

大意：树，每次操作可以将一个点及其$1,2,...,k-1$辈祖先都点亮，对于所有$1 le k le n$求最少操作多少次能点亮整棵树。

贪心的点叶子一定是对的。设叶子有$L$个。那么答案的上界是$O(L+frac{n}{k})$

我们对于每个节点求出$a[i]$表示这个节点到子树里最近的叶子的距离。然后丢进$vector$里。

可以发现除了叶节点，$a[i]=k$的点一定是最先被操作的。然后拿个优先队列依次操作，每次操作前判定这个点是否已经被点亮。

所以弄一个$dfs$序+线段树。维护每个节点的子树内，被操作过的点的最小深度，与$dep[p]+k$比较一下即可。

预处理叶子个数后。入队点个数是调和级数。所以总复杂度是$O(nlog^2n)$

#include<bits/stdc++.h>
using namespace std;
#define S 100005
vector<int>s[S],v[S]; priority_queue<pair<int,int> >q;
int n,dep[S],ans[S],L,mnd[S],f[19][S],dfn[S],tim,t[S<<2],dfr[S],Q[S],T;
void pre(int p,int fa){
    dep[p]=dep[fa]+1; f[0][p]=fa; mnd[p]=n+1; dfn[p]=++tim;
    for(int i=1;i<19;++i)f[i][p]=f[i-1][f[i-1][p]];
    for(int i=0,y;y=i<s[p].size()?s[p][i]:0;++i)if(y!=fa)
        pre(y,p),mnd[p]=min(mnd[p],mnd[y]);
    dfr[p]=tim;
    if(mnd[p]==n+1)mnd[p]=dep[p],L++;v[mnd[p]-dep[p]].push_back(p);
}
int Fa(int p,int k){for(int i=18;~i;--i)if(k&1<<i)p=f[i][p];return p;}
#define lc p<<1
#define rc lc|1
#define md (L+R>>1)
void mdf(int x,int w,int p=1,int L=1,int R=n){
    if(L==R)return t[p]=w,void();
    if(x<=md)mdf(x,w,lc,L,md);else mdf(x,w,rc,md+1,R);
    t[p]=min(t[lc],t[rc]);
}
int ask(int l,int r,int p=1,int L=1,int R=n){
    if(l<=L&&R<=r)return t[p];
    return min(l<=md?ask(l,r,lc,L,md):n+n,r>md?ask(l,r,rc,md+1,R):n+n);
}
int main(){//freopen("tree2.in","r",stdin);
    cin>>n; memset(t,0x3f,sizeof t);
    for(int i=1,a,b;i<n;++i)scanf("%d%d",&a,&b),s[a].push_back(b),s[b].push_back(a);
    pre(1,0);
    for(int i=0;i<v[0].size();++i)mdf(dfn[v[0][i]],dep[v[0][i]]);
    for(int k=1;k<=n;++k){
        for(int i=0;i<v[k].size();++i)q.push(make_pair(dep[v[k][i]],v[k][i]));
        while(!q.empty()){
            int p=q.top().second,x;q.pop();
            if(ask(dfn[p],dfr[p])<dep[p]+k)continue;
            mdf(dfn[p],dep[p]); Q[++T]=dfn[p]; ans[k]++;
            if(x=Fa(p,k))q.push(make_pair(dep[x],x));
        }while(T)mdf(Q[T],n+n),T--;
    }int q,x;cin>>q;while(q--)scanf("%d",&x),printf("%d
",ans[min(n,x)]+L);
}

T2：排列统计

大意：一个长为$n$的排列，随机进行$k$次两元素交换，求最后的序列中$cnt$的期望。

$cnt$定义为：从前往后扫，如果当前值是前缀最大值，$cnt++$。$n le 100,k le 80$

枚举$x,y$表示最终序列中位置$x$上是数字$y$。

设$dp[i][j][0/1/2/3/4]$表示交换了$i$次后$[1,x-1]$中有$j$个大于$y$的数。

$0/2$表示$a[x]>y$。$1/3$表示$a[x]<y$。$4$表示$a[x]=y$

设$a[p]=y$。$0/1$表示$p>x$。$2/3$表示$p<x$。显然$4$表示$p=x$

然后就可以转移了，一共有$39$种转移。时间复杂度$O(39kn^3)$。常数很小。

然而最大的测试点依旧跑了$3.4s$。最开始时限开$2s$有点过了。$8s$是不是有点多了。。？

常数不重要，这题写出来已经不容易了。。

#include<bits/stdc++.h>
using namespace std;
#define mod 1000000007
int qp(int b,int t,int a=1){for(;t;t>>=1,b=1ll*b*b%mod)if(t&1)a=1ll*a*b%mod;return a;}
int p[111],a[111],dp[2][111][5],ans,k,nw,nx=1,I,s,n;
void go(int t,int j,int r){if(I+j>=0)dp[nx][I+j][t]=(dp[nx][I+j][t]+1ll*r*dp[nw][I][s])%mod;}
int main(){
    cin>>n>>k; for(int i=1;i<=n;++i)scanf("%d",&a[i]),p[a[i]]=i;
    for(int x=1;x<=n;++x)for(int y=x;y<=n;++y){
        int c=0,R=min(x-1,n-y),r=1+(x-1)*(x-1)+(n-x)*(n-x);memset(dp,0,sizeof dp);
        for(int i=1;i<x;++i)c+=a[i]>y;
        dp[nw][c][(a[x]==y)<<2|(p[y]>x)<<1|a[x]>y]=1;
        for(int _=1;_<=k;++_,nw^=1,nx^=1)for(I=0;I<=R;++I){
            #define IF if(dp[nw][I][s])
            #define ls (LS-(s<2))
            #define rb (RB-(s&1))
            #define rs (n-x-rb-(s&2?1:0))
            int lb=I,LS=x-lb-1,RB=n-y-lb;
            s=4;IF go(0,0,ls*2),go(1,-1,lb*2),go(2,0,rs*2),go(3,0,rb*2);
            for(s=0;s<4;++s)IF go(4,s==1,2);
            for(s=0;s<4;s+=2)IF go(s,0,2*(ls+rs)),go(s^1,0,2*rb),go(s^1,-1,2*lb);
            for(s=1;s<4;s+=2)IF go(s,0,2*(lb+rb)),go(s^1,0,2*rs),go(s^1, 1,2*ls);
            for(s=0;s<2; ++s)IF go(s^2, 1,rb*2),go(s^2,0,rs*2);
            for(s=2;s<4; ++s)IF go(s^2,-1,lb*2),go(s^2,0,ls*2);
            for(s=0;s<5; ++s)IF go(s,0,ls*rs*2+lb*rb*2+r),go(s,1,ls*rb*2),go(s,-1,lb*rs*2),dp[nw][I][s]=0;
        }ans=(ans+dp[nw][0][4])%mod;
    }cout<<1ll*ans*qp(qp(n*n,k),mod-2)%mod<<endl;
}

T3：归并排序

大意：长度为$2$的整次幂的排列。执行正常的归并排序，然而在递归到长度为$2$的区间时会随机返回两种情况之一。

支持操作：询问$x$最后出现在位置$y$的概率，以及支持交换原始序列中两个数的位置。$nle 2^{16},qle 10^5$

不难发现，如果递归边界的两个数是$x,y(x<y)$

那么排对了就相当于是$x,y$。排错了相当于是$y,y+0.5$

所以每个数对应着两个可能的值，概率都是$frac{1}{2}$且互相独立。分开考虑贡献，期望有多少数比询问的数小，概率是多少。

把每个数对应的两个数视为一个区间，询问的数视为两个点：

要么整个区间都比点小，排名直接$+2$，要么大，排名不变，要么可大可小，直接组合数计算。

树状数组维护左右端点的值，每次就相当于是求前后缀和了。时间复杂度$qlogn$

被玄学了。同一份代码交两次结果不一样。迷茫。

#include<bits/stdc++.h>
using namespace std;
#define S 1<<18
#define mod 1000000007
int L[S],R[S],a[S],n,iv,fac[S],finv[S],q,y;
void add(int*t,int p,int v){for(;p<=n*2+2;p+=p&-p)t[p]+=v;}
int ask(int*t,int p,int a=0){for(;p;p^=p&-p)a+=t[p];return a;}
int qp(int b,int t,int a=1){for(;t;t>>=1,b=1ll*b*b%mod)if(t&1)a=1ll*a*b%mod;return a;}
int C(int b,int t){return t<0||b<t?0:1ll*fac[b]*finv[t]%mod*finv[b-t]%mod;}
void ctb(int x,int v=1){
    int y=a[x],z=a[x^1]; if(y>z)swap(y,z);
    add(R,z*2,v);add(R,z*2+1,v);
    add(L,n*2+2-y*2,v);add(L,2*n+2-z*2,v);
}
int cal(int x){
    int l=ask(R,x-1),r=ask(L,2*n+3-x);
    return 1ll*C(n-l-r,y-l)*qp(2,l)%mod*qp(2,r)%mod;
}
int main(){//freopen("10.in","r",stdin);freopen("0.out","w",stdout);
    cin>>n; iv=qp(qp(2,n+1),mod-2);
    for(int i=0;i<n;++i)scanf("%d",&a[i]);
    for(int i=0;i<n;i+=2)ctb(i);
    for(int i=fac[0]=1;i<=n;++i)fac[i]=1ll*fac[i-1]*i%mod;
    finv[n]=qp(fac[n],mod-2);
    for(int i=n-1;~i;--i)finv[i]=finv[i+1]*(i+1ll)%mod;
    scanf("%d",&q);
    for(int o,x;q--;){
        scanf("%d%d%d",&o,&x,&y);x--;y--;
        if(n==1&&o==2)puts(y?"0":"1");
        else if(o==1)ctb(x,-1),ctb(y,-1),swap(a[x],a[y]),ctb(x),ctb(y);
        else if(a[x]>a[x^1])printf("%lld
",2ll*cal(a[x]*2)*iv%mod);
        else printf("%lld
",1ll*iv*(cal(a[x]*2)+cal(a[x^1]*2+1))%mod);
    }
}