BZOJ

题意：

　　给定两个序列$a$和$b$，让它们进行匹配，求出使得$a_i > b_j$的个数比$a_i < b_j$的个数恰好多$k$，求这样的匹配方法数

题解：

　　这题的各种表示有一点相似又截然不同，很容易混淆。

　　直接求恰好满足$k$对不好求，所以先放宽条件，这样子有利于构造动规方程。

　　先用$f_{i, j}$表示在前$i$个中，至少选择$j$个$a > b$的匹配的方案数（是匹配的方案数，只关心匹配那一部分，不关心其它的部分），容易得到动规方程：

　　　　　　　　　　　　　　　　　　　　　ƒ_i,j = ƒ_{i - 1,j} + (Last_i - (j - 1)) * ƒ_{i - 1,j - 1}

　　其中$Last_i$表示第一个小于$a_i$的$b_j$。

　　$(Last_i - (j - 1))$表示原有$Last_i$种选择，被选走了$j - 1$种，此时因为是“至少”，所以其它的匹配是不用管的。

　　那么现在考虑求出恰好为$k$的方案数。

　　首先令$g_i$表示前$N$个$a$中，满足至少有$i$个$a > b$的方案数，那么

　　　　　　　　　　　　　　　　　　　　　 g_i = ƒ_N,j * (N - i) !

　　这时候才考虑了其它的部分，所以需要乘上阶乘。

　　再令$f'_i$表示恰好满足$i$组的方案数，那么考虑容斥，在所有的$g_j$中，每个$f'_i (i > j)$被算了$C_i^j$次，因为不考虑其它的，仅$i$个已匹配好的任意取$j$个，其它的随便排，正好被$g_j$囊括，当然这一部分是多余的，所以

　　　　　　　　　　　　　　　　　　　　　 ƒ'_i = g_j - C_{j, i} * ƒ'_j (j > i)

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

#define MOD 1000000009

using namespace std;

typedef long long LL;

const int MAXN = 2000 + 10;

LL g[MAXN][MAXN];

LL f[MAXN]= {0};

LL fac[MAXN];
LL C[MAXN][MAXN];

int N, K;

int Candy[MAXN], Pill[MAXN];

int Last[MAXN]= {0};

void Preparation () {
    fac[0] = 1;
    for (int i = 1; i <= N; i ++)
        fac[i] = fac[i - 1] * i % MOD;
    
    for (int i = 0; i <= N; i ++)
        C[i][0] = 1;
    for (int i = 1; i <= N; i ++)
        for (int j = 1; j <= i; j ++)
            C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}

int main () {
    scanf ("%d%d", & N, & K);
    
    Preparation ();
    
    for (int i = 1; i <= N; i ++)
        scanf ("%d", & Candy[i]);
    for (int i = 1; i <= N; i ++)
        scanf ("%d", & Pill[i]);
    
    sort (Candy + 1, Candy + N + 1);
    sort (Pill + 1, Pill + N + 1);
    
    for (int i = 1; i <= N; i ++)
        for (int j = N; j >= 1; j --)
            if (Pill[j] < Candy[i]) {
                Last[i] = j;
                break;
            }
    
    for (int i = 0; i <= N; i ++)
        g[i][0] = 1;
    for (int i = 1; i <= N; i ++)
        for (int j = 1; j <= i; j ++)
            g[i][j] = (g[i - 1][j] + (Last[i] - j + 1) * g[i - 1][j - 1] % MOD) % MOD;
    
    for (int i = N; i >= 1; i --) {
        f[i] = g[N][i] * fac[N - i] % MOD;
        for (int j = i + 1; j <= N; j ++)
            f[i] = ((f[i] - C[j][i] * f[j] % MOD) % MOD + MOD) % MOD;
    }
    
    printf ("%lld
", f[(N + K) >> 1]);
    
    return 0;
}

/*
4 2
5 35 15 45
40 20 10 30
*/