HDU5852 Intersection is not allowed!

There are K pieces on the chessboard.

The size of the chessboard is N*N.

The pieces are initially placed on the top cells of the board.

A piece located on (r, c) can be moved by one cell right to (r, c + 1) or one cell down to (r+1, c).

Your task is to count how many different ways to move all pieces to the given positions at the bottom of the board.

Furthermore, the paths of the pieces mustn’t intersect each other.

InputThe first line of input contains an integer T-the number of test cases.

Each test case begins with a line containing two
integers-N(1<=N<=100000) and K(1<=K<=100) representing the
size of the chessboard and the number of pieces respectively.

The second line contains K integers: 1<=a1<a2<
…<aK<=N representing the initial positions of the pieces. That is,
the pieces are located at (1, a1), (1, a2), …, (1, aK).

Next line contains K integers: 1<=b1<b2<…<bK<=N
representing the final positions of the pieces. This means the pieces
should be moved to (N, b1), (N, b2), …, (N, bK).

OutputPrint consecutive T lines, each of which represents the number of different ways modulo 1000000007.Sample Input

1
5 2
1 2
3 4

Sample Output

50

数学问题 容斥 矩阵行列式 脑洞题

假如只有一个起点一个终点，显然是一个基本的组合数问题，从所有步数中选n-1步向下走，方案为 $ ans = C(b-a+n-1,n-1) $

如果有两个起点两个终点，则是总方案数减去路径交叉的方案数。路径相交可以理解为两人交换了目的地，所以方案为

　　$ ans = C(b_1-a_1+n-1,n-1)*C(b_2-a_2+n-1,n-1) - C(b_1-a_2+n-1,n-1)*C(b_2-a_1+n-1,n-1)$

显然枚举起点和终点有几对逆序对，可以容斥计算出答案，显然这样TLE了

但这个逆序对数量决定加还是减的容斥可以让我们联想到另一个东西——矩阵行列式。

从矩阵的每一行选一列，将选的每一个位置的值乘起来，乘以(-1)^(逆序对数)，即是这一部分对行列式值的贡献，所有的选法的贡献叠加起来，就是矩阵行列式的值。

那么我们只要将每个(u to v)的关系用矩阵表示，再求矩阵行列式的值就是答案了。

 /*by SilverN*/
 #include<iostream>
 #include<algorithm>
 #include<cstdio>
 #include<cmath>
 #include<cstring>
 #define LL long long
 using namespace std;
 const int mxn=;
 const int mod=1e9+;
 int read(){
     int x=,f=;char ch=getchar();
     while(ch<'' || ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>='' && ch<=''){x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int fac[mxn],inv[mxn];
 void init(){
     fac[]=fac[]=;inv[]=inv[]=;
     for(int i=;i<mxn;i++){
         fac[i]=(LL)fac[i-]*i%mod;
         inv[i]=((-mod/i*(LL)inv[mod%i])%mod+mod)%mod;
     }
     for(int i=;i<mxn;i++)inv[i]=(LL)inv[i]*inv[i-]%mod;
     return;
 }
 int ksm(int a,int k){
     int res=;
     while(k){
         if(k&)res=(LL)res*a%mod;
         a=(LL)a*a%mod;
         k>>=;
     }
     return res;
 }
 int f[][];
 int Gauss(int n){
     int ft=;
     for(int i=;i<=n;i++){
         if(!f[i][i]){
             int p=i;
             for(int j=i+;j<=n;j++)if(f[j][i]){p=j;break;}
             if(p==i)return ;
             for(int j=i;j<=n;i++)swap(f[i][j],f[p][j]);
             ft=-ft;
         }
         int IV=ksm(f[i][i],mod-);
         for(int j=i+;j<=n;j++){
             int tmp=(LL)f[j][i]*IV%mod;
             for(int k=i;k<=n;k++){
                 f[j][k]=((LL)f[j][k]-(LL)tmp*f[i][k])%mod;
             }
         }
     }
     int res=ft;
     for(int i=;i<=n;i++){
         res=(LL)res*f[i][i]%mod;
     }
     return (res+mod)%mod;
 }
 int n,K;
 int a[mxn],b[mxn];
 int C(int n,int m){
     if(n<m)return ;
     return (LL)fac[n]*inv[m]%mod*inv[n-m]%mod;
 }
 int path(int x,int y){
     return (LL)C(b[y]-a[x]+n-,n-);
 }
 void solve(){
     memset(f,,sizeof f);
     for(int i=;i<=K;i++){
         for(int j=;j<=K;j++){
             f[i][j]=path(i,j);
         }
     }
     int ans=Gauss(K);
     printf("%d\n",ans);
     return;
 }
 int main(){
 //    freopen("in.txt","r",stdin);
     init();
     int T=read(),i;
     while(T--){
         n=read();K=read();
         for(i=;i<=K;i++)a[i]=read();
         for(i=;i<=K;i++)b[i]=read();
         solve();
     }
     return ;
 }