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;
}

Codeforces 285 E. Positions in Permutations

解题思路 :

猜你喜欢