转载zroi 9.16普转提（代码是自己的）

Link:

A:

套路题结果想了好久……

排序二叉树的性质就是中序遍历单调递增

于是只考虑当前树的中序遍历的序列即可，与树的形态无关

#include<bits/stdc++.h>
#define maxn 100005
using namespace std;
typedef long long ll;
int n,fa[maxn],ch[maxn][2],x;
ll st[maxn],a[maxn];
int top=0;
void dfs(int i){
    if(ch[i][0]) dfs(ch[i][0]);
    st[++top]=a[i];
    if(ch[i][1]) dfs(ch[i][1]);
} 
ll q[maxn];
int rear=0;
void run(ll x){
    /*if(x>=q[rear]){
        q[++rear]=x;
        return;
    }
    int l=1,r=rear,mid;
    while(l<=r){
        mid=(l+r)>>1;
        if(q[mid-1]<=x&&x<q[mid]){q[mid]=x;return;}
        if(x<q[mid-1]) r=mid-1;
        else l=mid+1; 
    }*/
    int t=upper_bound(q+1,q+rear+1,x)-q;
    if(t==rear+1) q[++rear]=x;
    else q[t]=x;//将刚好大于它的代替 
}
void init(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
    for(int i=2;i<=n;i++){
        scanf("%d%d",&fa[i],&x);
        ch[fa[i]][x]=i;
    }
    dfs(1);
    
    for(ll i=1;i<=top;i++) st[i]=st[i]-i;
    
    q[0]=-10000000000;
    for(int i=1;i<=top;i++) run(st[i]);
    
    int ans=n-rear;
    printf("%d",ans);
}
int main(){
    init();
    
    return 0;
}

将序列改成严格单调增想到最大化不变的数，但直接LIS求的是改为非严格单调增的数

一个将严格单调增问题改为非严格的套路是将数aiai替换成ai−iai−i，对转换后序列求LIS即可

（其实也可以理解为在严格单增问题中能拓展的条件为a[i]−a[k]≥i−ka[i]−a[k]≥i−k，那么也就是a[i]−i≥a[k]−ka[i]−i≥a[k]−k）

B:

长度可行性单调，对长度二分答案

发现区间[l,r][l,r]中存在kk的条件为：gcd(l...r)=min(l...r)=kgcd(l...r)=min(l...r)=k

区间最小和gcdgcd明显可以用RMQRMQ维护，但此题卡log2log2，因此只能用STST表来维护

#include<bits/stdc++.h>
#define maxn 500005
using namespace std;
int n,a[maxn],np=0,rt=0;
int gcd(int x,int y){
    if(y==0) return x;
    else return gcd(y,x%y);
}
int minv[maxn][20],gcdd[maxn][20],logg[maxn],w[25];
void ready(){
    w[0]=1;
    logg[0]=-1;
    for(int i=1;i<=20;i++) w[i]=w[i-1]*2;
    for(int i=1;i<=maxn-5;i++) logg[i]=logg[i/2]+1;
    for(int i=1;i<=n;i++){
        minv[i][0]=gcdd[i][0]=a[i];
    }
    for(int i=1;i<=logg[n];i++)//加个1保个险 
    for(int j=1;j<=n;j++)
    if(j+w[i]-1<=n){
        minv[j][i]=min(minv[j][i-1],minv[j+w[i-1]][i-1]);//本来是j+(1<<(i-1))-1+1
        gcdd[j][i]=gcd(gcdd[j][i-1],gcdd[j+w[i-1]][i-1]);
    } 
}
int cd1(int i,int j){
    int len=j-i+1;
    int t=logg[len];
    return min(minv[i][t],minv[j-w[t]+1][t]);
}
int cd2(int i,int j){
    int len=j-i+1;
    int t=logg[len];
    return gcd(gcdd[i][t],gcdd[j-w[t]+1][t]);
}
int st[maxn],top=0,yb[maxn],topp=0;
bool check(int mid){
    topp=0;
    bool ok=false;
    for(int i=1;i<=n-mid+1;i++){
        int j=i+mid-1;
        if(cd1(i,j)==cd2(i,j)){
            ok=true;
            yb[++topp]=i;
        }
    }
    if(ok){
        top=0;
        for(int i=1;i<=topp;i++) st[++top]=yb[i];
        return true;
    }
    return false;
}
void run(){
    int A=1,B=n,mid,ans;
    while(A<=B){
        mid=A+B>>1;
        if(check(mid))
        ans=mid,A=mid+1;
        else B=mid-1;
    }
    printf("%d %d
",top,ans-1);//L-R
    for(int i=1;i<=top;i++) printf("%d ",st[i]);
} 
void init(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    ready(); 
    run(); 
}
int main(){
    init();
    
    return 0;
}

如果只有询问用STST表O(1)O(1)询问

同时注意由于对一个数多次求gcdgcd不会影响区间gcdgcd值，因此可以直接用STST表维护gcdgcd

C:

很像以前冒泡排序相关题的一个TrickTrick：

由于交换序列是一个排列，因此每次交换后左右不可能再有交换，这样就拆为独立的子问题了

由于初始状态的值有规律是单调的，因此反向考虑问题：

对于当前区间[l,r][l,r]枚举交换位置ii，如果交换i,i+1i,i+1后左序列是[l,l+i−1][l,l+i−1]的一个排列则计算其贡献

dp[l][r]=dp[l][l+i−1]∗dp[l+i][r]∗Ci−1r−l+1−2dp[l][r]=dp[l][l+i−1]∗dp[l+i][r]∗Cr−l+1−2i−1

#include<bits/stdc++.h>
#define maxn 55
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
ll c[maxn][maxn],dp[maxn][maxn];
int p[maxn],n;
void ready(){
    for(int i=0;i<=50;i++){
        c[i][0]=1;
        for(int j=1;j<=i;j++)
        c[i][j]=(c[i-1][j-1]+c[i-1][j])%mod;
    }
}
ll dfs(int len,int now){
    if(dp[len][now]!=-1) return dp[len][now];
    if(len==1) return dp[len][now]=1;
    ll ans=0;int j,k,pos=0,t[maxn];//pos和t只有内定了给，不然要重 函数递归时会改变 
    for(int i=1;i<=n;i++)
    if(p[i]>=now&&p[i]<now+len) t[++pos]=p[i];//pos==len
    for(int i=1;i<pos;i++){
        swap(t[i],t[i+1]);//枚举交换的位置
        for(j=1;j<=i;j++)//判断是否满足
        if(t[j]>=now+i) break;//最多为now+i-1;
        for(k=i+1;k<=pos;k++)
        if(t[k]<now+i)  break;//最小为now+i; 
        if(j>i&&k>pos){
            ll t1=dfs(i,now);
            ll t2=dfs(pos-i,now+i);
            ans=(ans+t1*t2%mod*c[pos-2][i-1]%mod)%mod;//第一个:now~now+i-1 第二个now+i~now+len-1; 
                                    //在这之前进行n-2次交换,前i-1次选择前面来处理前面的i个 
        }
        swap(t[i],t[i+1]);
    }
    return dp[len][now]=ans; 
}
void init(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&p[i]);
    memset(dp,-1,sizeof(dp));
    dfs(n,0);
    if(dp[n][0]==-1) printf("%d",0);
    else printf("%lld",dp[n][0]);
}
int main(){
    ready();
    init();
    
    return 0;
}

注意这里每次处理的[l,r][l,r]的排列是pp的子序列！

（处理到该子问题时能保证数在pp中的相对位置不变）

D:

关键在于贡献为2R+C2R+C，可以理解为对每一个子集算一次贡献

接下来算每个集合被包含的期望次数即可：

res=∑Cin∗Cjn∗Ck−numm−numCkmres=∑Cni∗Cnj∗Cm−numk−numCmk

其中numnum为如果ii行jj列全涂黑的个数，预处理组合数即可

#include<bits/stdc++.h>
#define maxn 305
using namespace std;
int n,m,k;
double a[maxn],b[maxn*maxn];//b:(k-x,m-x)/(k,m) 而x最多为n^2
void ready(){
    a[0]=1.0;
    for(int i=1;i<=n;i++) a[i]=a[i-1]*(n-i+1)*1.0/i;
    b[0]=1;
    for(int i=1;i<=n*n;i++) b[i]=b[i-1]*(k-i+1)*1.0/(m-i+1); 
} 
void outt(){
    printf("1");
    for(int i=1;i<=99;i++) printf("0");
}
int main(){
    scanf("%d%d%d",&n,&m,&k);
    ready();
    double ans=0;
    for(int i=0;i<=n;i++)
    for(int j=0;j<=n;j++){
        int x=(i+j)*n-i*j;
        if(x>k) break;//再加只会更多 
        ans+=a[i]*a[j]*b[x];
    } 
    if(ans>1e99) outt();
    else printf("%lf",ans);
    
    return 0;
}