题意

给定两个长度为 $n$ 的序列 $x,y$，保证这两个序列没有相同的元素，求有多少匹配满足 $x_i > y_i$ 的 $i$ 个数的比满足 $x_i<y_i$ 的 $i$ 的个数多 $k$ 。

数据范围

对于 $30\%$ 的测试数据，$n \le 15$
对于 $70\%$ 的测试数据，$n \le 200$
对于 $100\%$ 的测试数据， $1 \le n \le 2000 , 0 \le k \le n$，$x_i,y_i$ 为正整数并在int 以内。

题解

首先，由于题目给的所有数都不相同，所以每次要不就是 $x_i>y_i$ 要不就是 $x_i<y_i$。

因此题目相当于是求恰好有 $(k+n)/2$ 组 $x_i>y_i$ 的方案数，也因此无解的判法就是 $k+n$ 为奇数。

显然对于 $20\%$ 的数据，我们可以考虑枚举一下 $x$ 的排列，然后暴力 check 即可，复杂度 $O(n!)$

对于 $30\%$ 的数据，我们可以考虑动态规划的做法：

记 $f_{j,S}$ 表示考虑到前 $|S|$ 个 $x$ 内的数，满足 $x_i>y_i$ 的数量一共有 $j$ 组，而在序列 $y$ 中取了 $S$ 这样的数。$S$ 内的 $0/1$ 表示在 $y$ 中取或者不取。

那么显然转移就是

这样复杂度就是 $O(n^2\times 2^n)$

那么这对于 $n\le 2000$ 的数据范围显然是非常爆炸的，而又感觉到这个状压实在是非常的浪费，那么怎么把它优化掉呢？

如果我们能直接地求出 $f_{j,|S|}$ （或者记为 $f_{i,j}$）的值的话，那么这个状压的复杂度就可以吃掉了。

具体做法的话，我们考虑每次塞进了一个新的数，那么可以钦定它比较的结果是大的或者是小的对吧

设当前状态是 $f_{i,j}$，对于新加入的 $i+1$，如果是大的，那要把 $f_{i,j}$ 向 $f_{i+1,j+1}$ 转移，如果是小的，就要向 $f_{i+1,j}$ 转移。

那么有多少种转移方案呢？

我们首先记 $x$ 中每个数能比 $y$ 中的多少个数大，记为 $win_i$，然后把 $x$ 和 $y$ 都从小到大排序，这样一来求得的 $win_i$ 也是从小到大排序的

如果它是对大的作出的贡献，那么考虑他能得到大这个结果的数目只有 $win_i$ 个，而我们已经用掉 $j$ 个了，那么就只剩下 $win_i-j+1$ 种方案让他成功了

如果它是对小的作出的贡献，那么我们还是已经用掉 $j$ 个能得到大的结果的数目了，那么还有 $i+(j-win_i)$ 可以让他随便取小

于是转移方程就变成了这样：

然后 orz alphaGem 说这么推会爆负数，就是说在乘上 $(win_i-j+1)$ 的地方会爆负，然后我的想法是由于你 $win_i$ 是单调递增的，也就是说如果 $win_i<j$ 了，就意味着这个状态是不可能存在的（不可能会使得有一个 $win_{i-1}>j$ 然后 $win_i<j$ 的情况。

代码如下：

#include <bits/stdc++.h>
#define R register
#define LL long long
template<class TT>inline TT Max(R TT a,R TT b){return a<b?b:a;}
template<class TT>inline TT Min(R TT a,R TT b){return a<b?a:b;}
using namespace std;
template<class TT>inline void read(R TT &x){
    x=0;R bool f=false;R char c=getchar();
    for(;c<48||c>57;c=getchar())f|=(c=='-');
    for(;c>47&&c<58;c=getchar())x=(x<<1)+(x<<3)+(c^48);
    (f)&&(x=-x);
}
const int mod = 1e9+9;
int n,k;
namespace subtask_1{
    int x[11],y[11];
    int main(){
        for(R int i=1;i<=n;++i)read(x[i]);
        for(R int j=1;j<=n;++j)read(y[j]);
        (k+=n)>>=1;
        sort(x+1,x+1+n);
        R int tmp=0,ans=0;
        do{
            tmp=0;
            for(R int i=1;i<=n;++i)if(x[i]>y[i])tmp++;
            if(tmp==k)++ans;
        }while(next_permutation(x+1,x+1+n));
        printf("%d\n",ans);
        return 0;
    }
}//true brute force
namespace subtask_2{
    int x[16],y[16],S;
    int f[20][20][1<<15];//f[i][j][s] means we consider first i numbers, win j times, opposite's state is s
    int main(){
        S=1<<n;(k+=n)>>=1;
        for(R int i=1;i<=n;++i)read(x[i]);
        for(R int i=1;i<=n;++i)read(y[i]);
        f[0][0][0]=1;
        for(R int i=1;i<=n;++i){//first i numbers
            for(R int j=0;j<=n;++j){//win j
                for(R int s=0;s<S;++s){//now state
                    for(R int t=1,tmp;t<=n;++t){//transform
                        if(s&(1<<(t-1)))continue;//not legal
                        tmp=j+(x[i]>y[t]);
                        R int &now=f[i][tmp][s|(1<<t-1)];
                        now=(now+f[i-1][j][s])%mod;
                    }
                }
            }
        }
        printf("%d\n",f[n][k][S-1]);
        return 0;
    }
}//states compressing recusion by bit
namespace total{
    int x[2222],y[2222];
    int win[2222];
    int f[2222][2222];
    int main(){
        (k+=n)>>=1;
        for(R int i=1;i<=n;++i)read(x[i]);
        for(R int i=1;i<=n;++i)read(y[i]);
        sort(x+1,x+1+n);
        sort(y+1,y+1+n);
        for(R int i=1,j=1;i<=n;){
            if(x[i]<y[j]||j>n){
                win[i]=j-1;
                ++i;
            }else j++;
        }
        for(R int i=f[0][0]=1;i<=n;++i){
            for(R int j=0;j<=i;++j){
                f[i][j]=((LL)f[i-1][j-1]*(win[i]-j+1)+(LL)f[i-1][j]*(i+j-win[i]))%mod;
            }
        }
        printf("%d\n",f[n][k]);
        return 0;
    }
}
int main(){
    read(n);read(k);
    if((n+k)&1)return puts("0")&0;
    if(n<=10)return subtask_1::main();
    if(n<=15)return subtask_2::main();
    return total::main();
}