Codeforces 285 E. Positions in Permutations

\(>Codeforces \space 285 E. Positions in Permutations<\)

题目大意 : 定义一个长度为 \(n\) 的排列中第 \(i\) 个元素是好的，当且仅当 \(i\)在排列中的位置 \(p_i\) 满足 \(|i - p_i| = 1\)，　给出 \(n, k\) 求长度为 \(n\) 的排列中恰好有 \(k\) 个元素是好的方案数

$1 \leq n \leq 1000, 0 \leq k \leq n $

解题思路 :

观察发现，直接求出答案貌似十分困难，不妨先 \(dp\) 出至少 \(k\) 个元素是好的方案数，然后再通过 容斥/反演 来解决

至少有 \(k\) 个元素是好的方案数等价于有 \(k\) 个位置存在匹配 \(|i-p_i| = 1\) ，剩余元素随便排列的方案数

设 \(f[i][j][0/1][0/1]\) 表示前 \(i\) 个元素和前 \(i\) 个位置产生了 \(j\) 对匹配，第 \(i\) 个元素和第 \(i\) 个位置是否已经被匹配的方案数

转移很显然，只需要枚举 \(i-1\) 上的元素和位置是否能和 \(i\) 上的元素和位置产生匹配即可

设 \(F(k)\) 表示至少有 \(k\) 个是好的方案数，那么 \(k = f[n][k] \times(n-k)!\)

考虑要求 \(Ans_k =\) 恰好有 \(k\) 个元素是好的方案数，那么有 \(Ans_k = \sum_{i = k}^{n} (-1)^{i-k} \times C_i^k \times F(i)\)

这个和最基础的容斥又有所不一样，简单的考虑，对于 \(i > k\) 的每一个 \(Ans_i\) ，其中任意选 \(k\) 个好元素都能更新到 \(Ans_k\) ，所以方案数是 \(C_i^k\) ，在容斥进行补集转换的时候需要乘上这个系数

往复杂了讲，这个涉及到容斥原理最本质的在集合上的运算，之前的 \(i\) 将表示所有大小为 \(i\) 的集合，那么每一个大小为 \(i\) 的集合在算到 \(Ans_k\) 的过程中都产生了 \(C_i^k\) 个不同的大小为 \(k\) 的集合，当中的具体证明可以看近年集训队论文

考虑到前面算 \(F(i)\) 的时候，两个不同的匹配方案可能会对应到同一个排列，这里等价于每一个大小为 \(i\) 的集合，选 \(k\) 个好元素得到的新集合可能相同，所以两个重复计数恰好抵消了

/*program by mangoyang*/
#include<bits/stdc++.h>
#define inf (0x7f7f7f7f)
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
typedef long long ll;
using namespace std;
template <class T>
inline void read(T &x){
    int f = 0, ch = 0; x = 0;
    for(; !isdigit(ch); ch = getchar()) if(ch == ‘-‘) f = 1;
    for(; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    if(f) x = -x;
}
#define N (2005)
#define int ll
const int Mod = 1000000007;
int js[N], inv[N], f[N][N][2][2], g[N], n, k;
inline int pow(int a, int b){
    int ans = 1;
    for(; b; b >>= 1, a = a * a % Mod)
        if(b & 1) ans = ans * a % Mod;
    return ans;
}
inline int C(int n, int i){ return js[n] * inv[i] % Mod * inv[n-i] % Mod; }
main(){
    read(n), read(k), f[0][0][0][0] = 1, js[0] = inv[0] = 1;
    for(int i = 1; i <= n; i++){
        js[i] = js[i-1] * i % Mod;
        inv[i] = pow(js[i], Mod - 2);
    }
    for(int i = 1; i <= n; i++)
        for(int j = 0; j <= n; j++){
            (f[i][j][0][0] += f[i-1][j][0][0] + f[i-1][j][1][1]) %= Mod;
            (f[i][j][0][0] += f[i-1][j][0][1] + f[i-1][j][1][0]) %= Mod;
            if(j >= 1 && i > 1){
                (f[i][j][1][0] += f[i-1][j-1][1][0] + f[i-1][j-1][0][0]) %= Mod;
                (f[i][j][0][1] += f[i-1][j-1][0][1] + f[i-1][j-1][0][0]) %= Mod;
            }
            if(j >= 2 && i > 1) (f[i][j][1][1] += f[i-1][j-2][0][0]) %= Mod;
        }
    for(int i = 0; i <= n; i++){
        int res = 0;
        (res += f[n][i][0][0] + f[n][i][1][0]) %= Mod;
        (res += f[n][i][0][1] + f[n][i][1][1]) %= Mod;
        g[i] = res * js[n-i] % Mod;
    }
    int ans = 0;
    for(int i = k; i <= n; i++){
        int p = ((i - k) & 1) ? Mod - 1 : 1;
        (ans += C(i, k) * p % Mod * g[i] % Mod) %= Mod;
    }
    cout << ans << endl;
    return 0;
}

原文地址：https://www.cnblogs.com/mangoyang/p/9368346.html