CF1151F

1151F - Sonya and Informatics

题意：有个长为n的01序列，求经过K次随机交换两个数之后这个序列非降的概率。n <= 100, k <= 1e9。

解：看到这个数据范围想到了矩阵快速幂...

先想一个暴力维护每个位置为1概率的DP，发现不独立...

然后想到PKUSC T2，单独确定每一位，但是这个东西不是排列，有相同的元素不好搞...

最后想到了thuPC摆家具，发现可以用那个套路。

发现最终每个状态的概率只跟距初态的距离有关。这里的距离是两个状态异或之后1的个数。

于是进行DP，设fij表示前i次操作，所得状态与初态异或后有j个1的概率。

转移有三种，分别是无用转移，挪一个1到初态的0中，挪一个1到初态的1中。

然后矩阵快速幂一下。

最后算答案的时候，我们还要算出有多少种状态满足条件，这就是一个组合数。然后除以这个组合数就行了。

#include <bits/stdc++.h>

const int N = 210, MO = 1e9 + 7;

int n, K, A[N], fac[N], inv[N], invn[N], a[N][N], ans[N][N], c[N][N], lm;

inline void Add(int &a, const int &b) {
    a += b;
    if(a >= MO) a -= MO;
    else if(a < 0) a += MO;
    return;
}

inline int qpow(int a, int b) {
    int ans = 1;
    while(b) {
        if(b & 1) {
            ans = 1ll * ans * a % MO;
        }
        a = 1ll * a * a % MO;
        b = b >> 1;
    }
    return ans;
}

inline int Inv(int x) {
    return qpow(x, MO - 2);
}

inline int iC(int n, int m) {
    if(n < 0 || m < 0 || n < m) return 0;
    return 1ll * invn[n] * fac[m] % MO * fac[n - m] % MO;
}

inline void mulself() {
    memset(c, 0, sizeof(c));
    for(int k = 0; k <= lm; k++) {
        for(int i = 0; i <= lm; i++) {
            if(!a[i][k]) continue;
            for(int j = 0; j <= lm; j++) {
                Add(c[i][j], 1ll * a[i][k] * a[k][j] % MO);
            }
        }
    }
    memcpy(a, c, sizeof(a));
    return;
}

inline void mul() {
    memset(c, 0, sizeof(c));
    for(int k = 0; k <= lm; k++) {
        for(int i = 0; i <= lm; i++) {
            if(!a[i][k]) continue;
            for(int j = 0; j <= lm; j++) {
                Add(c[i][j], 1ll * a[i][k] * ans[k][j] % MO);
            }
        }
    }
    memcpy(ans, c, sizeof(c));
    return;
}

int main() {
    scanf("%d%d", &n, &K);
    int cnt = 0, aim = 0;
    for(int i = 1; i <= n; i++) {
        scanf("%d", &A[i]);
        cnt += A[i];
    }
    for(int i = 1; i + cnt <= n; i++) {
        aim += A[i];
    }
    //int P = 1ll * Inv(n * (n - 1) / 2) * cnt % MO * (n - cnt) % MO;
    int P = Inv(n * (n - 1) / 2);
    fac[0] = inv[0] = invn[0] = 1;
    fac[1] = inv[1] = invn[1] = 1;
    for(int i = 2; i <= n; i++) {
        fac[i] = 1ll * i * fac[i - 1] % MO;
        inv[i] = 1ll * inv[MO % i] * (MO - MO / i) % MO;
        invn[i] = 1ll * invn[i - 1] * inv[i] % MO;
    }
    
    lm = n - cnt;
    for(int j = 0; j <= n - cnt; j++) {
        int t1 = 1ll * (cnt - j) * (n - cnt - j) % MO * P % MO;
        int t2 = 1ll * j * j * P % MO;
        Add(a[j][j], (1 - t1 + MO - t2 + MO) % MO);
        Add(a[j][j + 1], t1);
        Add(a[j][j - 1], t2);
    }
    for(int i = 0; i <= lm; i++) {
        ans[i][i] = 1;
    }
    
    while(K) {
        if(K & 1) {
            mul();
        }
        mulself();
        K >>= 1;
    }
    
    
    /*f[0][0] = 1;
    for(int i = 0; i < K; i++) {
        for(int j = 0; j <= n - cnt; j++) {
            //Add(f[i + 1][j], (1ll - P + MO) * f[i][j] % MO);
            int t1 = 1ll * (cnt - j) * (n - cnt - j) % MO * P % MO;
            int t2 = 1ll * j * j * P % MO;
            Add(f[i + 1][j + 1], 1ll * f[i][j] * t1 % MO);
            Add(f[i + 1][j - 1], 1ll * f[i][j] * t2 % MO);
            Add(f[i + 1][j], 1ll * f[i][j] * ((1 - t1 + MO - t2 + MO) % MO) % MO);
        }
    }*/
    
    int Ans = 1ll * ans[0][aim] * iC(n - cnt, aim) % MO * iC(cnt, aim) % MO;
    printf("%d
", (Ans + MO) % MO);
    return 0;
}

我的理解方式是，有两个集合S1，S2。S1里面是初态中为1的位置，S2是初态中为0的位置。我们要往S2里面放若干个1。每次可以不改变S2中1的个数，或者从S1拿一个1过来，或者从S2拿一个1出去。

代码写的时候没注意j = 0的边界，可能会数组越界，但是A了...