hdu 4779 Tower Defense 2013杭州现场赛

 /**
 题意： 有两种塔，重塔，轻塔。每种塔，能攻击他所在的一行和他所在的一列， 轻塔不 能被攻击，而重塔可以被至多一个塔攻击，也就是说重塔只能被重塔攻击。在一个n*m 的矩阵中，最少放一个塔，可放多个
 问，给定p个重塔，q个轻塔，问有多少种放法。。

 思路： 1、 一行中有两个重塔，
           2、 一列中有两个重塔
           3、 在该行及在该行塔所在的列只有一个塔，重塔或者轻塔。
 对以上三种情况
 挨个处理：
 1、 设有i行有两个重塔，j列有两个重塔，则一共占 i+2*j 行， j+2*i列，共用2*（i+j）个重塔，，因为一行或一列两个塔
 2、 对剩余的塔，进行枚举，0<-->剩余的塔，。。，枚举这些塔中重塔的个数进行枚举

 对于1： 在行中有两个重塔 c(n,i)*c(m,2*i)*((2*i)!/2^i)   意思 是在n行中选i行，在m列中选2*i列，  对于选出来的2*i  列，分成i组，需要进行全排列，但是组内不需要进行全排列。。所以为(2*i)!/2^i
           在列中有两个重塔，c(m-2*i,j)*c(n-i,2*j)*((2*j)!/2^j)  原理同上

 对于2:设有k个塔， 在剩余的n-(i+2*j) 行  m-(2*i+j) 列中 选 k个 点 ，k最大为  p-2*(i+j)+q
      对于k个塔，则重塔最多有b =  min （k， p-2*(i+j) ） 个，  最少有a =  max（0，k-q） 个
      k个塔，最少 a ，最多b  则为（c[k][0]+c[k][1]...+c[k][b]）- (c[k][0]+c[k][1]+...+c[k][a-1])；
 最后将不放的情况减掉即可，也就是减1；
 注意： 在计算的过程中注意%mod
 **/

 #include <iostream>
 #include <algorithm>
 using namespace std;
 const long long mod = ;
 const int maxn = ;
 const long long R = ;
 long long c[maxn][maxn] ;
 long long cs[maxn][maxn];
 long long sq[maxn];
 long long fac[maxn*];
 void init(){
     c[][] =;
     for(int i=;i<maxn;i++){
         c[i][] =c[i][i]=;
         for(int j=;j<i;j++){
             c[i][j] = (c[i-][j-]+c[i-][j])%mod;
         }
     }
     fac[] =;
     for(int i=;i<maxn*;i++)
         fac[i] = (fac[i-]*i)%mod;

     for(int i=;i<maxn;i++){
         cs[i][] = ;
         for(int j=;j<=i;j++){
             cs[i][j] = (cs[i][j-]+c[i][j])%mod;
         }
     }

     sq[] =;
     sq[] =;
     long long rr = R;
     for(int i=;i<maxn;i++){
         rr = (rr*R)%mod;
         sq[i] = (fac[*i]*rr)%mod;
     }
 }

 long long cal(long long n,long long m,long long p){
     return ((c[n][p]*c[m][*p])%mod*sq[p])%mod;
 }

 long long solve(int z,int x,int y){
     if(x>){
         return ((cs[z][y]-cs[z][x-])%mod+mod)%mod;
     }
     return cs[z][y]%mod;
 }

 int main()
 {
     init();
     int n,m,p,q;
     int t;
     cin>>t;
     while(t--){
         cin>>n>>m>>p>>q;
         long long  res =;
         for(int i=;i<=n;i++){
             for(int j=;j<=m;j++){
                 if((n>=(i+*j))&&(m>=(*i+j))&&((p-*(i+j))>=)){
                     int tn = n-(i+*j);
                     int tm = m-(*i+j);
                     int tp = p-*(i+j);
                     int tq = q;
                     long long ans = (cal(n,m,i)*cal(m-*i,n-i,j))%mod;
                     for(int k=;k<=tp+tq;k++){
                         if(k>min(tn,tm))
                             continue;
                         int maxp = min(k,tp);
                         int minp = max(,k-tq);
                         long long tmp = ((solve(k,minp,maxp)*c[tn][k])%mod*c[tm][k])%mod;
                         tmp = (tmp*fac[k])%mod;
                         res = (res+tmp*ans)%mod;
                     }
                 }
             }
         }
         res = ((res-)%mod+mod)%mod;
         cout<<res<<endl;
     }
     return ;
 }