牛客国庆集训派对Day_1~3

Day_1

A.Tobaku Mokushiroku Kaiji

题目描述

Kaiji正在与另外一人玩石头剪刀布。双方各有一些代表石头、剪刀、布的卡牌，每局两人各出一张卡牌，根据卡牌的内容决定这一局的胜负。胜负规则为：石头赢剪刀、剪刀赢布、布赢石头、相同为平局。每张卡牌至多被使用一次。

已知双方的卡牌数量，问Kaiji最多赢几局？

输入描述:

一行六个数字0 ≤ a, b, c, d, e, f ≤ 50，a,b,c分别表示Kaiji的石头、剪刀、布的牌的数量，d,e,f分别表示此时另一人的石头、剪刀、布的牌的数量。

输出描述:

一个整数表示Kaiji最多赢几局。

输入例子:

29 7 41 14 12 42

输出例子:

33

-->

示例1

输入

29 7 41 14 12 42

输出

33
解题思路：简单取三个最小即可。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 int a,b,c,d,e,f,ans;
 int main(){
     while(cin>>a>>b>>c>>d>>e>>f){
         ans=a>e?e:a;
         ans+=b>f?f:b;
         ans+=c>d?d:c;
         cout<<ans<<endl;
     }
     return ;
 }

C.Utawarerumono

题目描述

算术是为数不多的会让Kuon感到棘手的事情。通常她会找Haku帮忙，但是Haku已经被她派去买东西了。于是她向你寻求帮助。
给出一个关于变量x,y的不定方程ax+by=c，显然这个方程可能有多个整数解。Kuon想知道如果有解，使得p₂*x²+p₁*x+q₂*y²+q₁*y最小的一组整数解是什么。为了方便，你只需要输出p₂*x²+p₁*x+q₂*y²+q₁*y的最小值。

输入描述:

第一行三个空格隔开的整数a,b,c(0 ≤ a,b,c≤ 10^5)。

第二行两个空格隔开的整数p1,p2,(1 ≤ p1,p2 ≤ 10^5)。

第三行两个空格隔开的整数q1,q2,(1 ≤ q1,q2 ≤ 10^5)。

输出描述:

如果方程无整数解，输出“Kuon”。
如果有整数解，输出p2*x^2+p1*x+q2*y^2+q1*y的最小值。

输入例子:

2 2 1
1 1
1 1

输出例子:

Kuon

-->

示例1

输入

2 2 1
1 1
1 1

输出

Kuon

示例2

输入

1 2 3
1 1
1 1

输出

4
解题思路：法一： ∵0 ≤ a,b,c ≤ 1e5, ∴ x∈[-1e5,2e5] ∧ x∈Ν。因此只需暴力枚举一下x的值，注意模数不能作0，单独分情况讨论即可。法二：扩展gcd+公式推导。
AC代码一：暴力。

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 LL a,b,c,p1,p2,q1,q2,x,y,ans;
 int main(){
     while(cin>>a>>b>>c){
         cin>>p1>>p2>>q1>>q2;ans=LONG_LONG_MAX;
         if((a&&!(c%a))&&!b)x=c/a,ans=p2*x*x+p1*x;
         else if(!a&&(b&&!(c%b)))y=c/b,ans=q2*y*y+q1*y;
         else if(a&&b){
             for(LL i=-;i<=;++i){
                 y=(c-a*i);
                 if(y%b==)y/=b,ans=min(ans,p2*i*i+p1*i+q2*y*y+q1*y);
             }
         }
         if(ans!=LONG_LONG_MAX)cout<<ans<<endl;
         else cout<<"Kuon"<<endl;
     }
     return ;
 }

AC代码二：扩展欧几里得+公式推导。

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 typedef long double LD;
 LL a,b,c,p1,p2,q1,q2,x,y,ans,gcd,ubt;LD A,B,C,t;
 LL f(LL x,LL y){return p2*x*x+p1*x+q2*y*y+q1*y;}
 LL exGcd(LL a,LL b,LL &x,LL &y){
     if(b==){x=;y=;return a;}
     LL r=exGcd(b,a%b,x,y);
     LL t=x;x=y;y=t-a/b*y;
     return r;
 }
 int main(){
     while(cin>>a>>b>>c){
         cin>>p1>>p2>>q1>>q2;ans=LONG_LONG_MAX;
         gcd=exGcd(a,b,x,y);
         if((c%gcd)||!gcd){cout<<"Kuon"<<endl;continue;}
         if((a&&!(c%a))&&!b)ans=f(c/a,);
         else if(!a&&(b&&!(c%b)))ans=f(,c/b);
         else{
             a/=gcd,b/=gcd,c/=gcd,x*=c;//x为exgcd求出来的一个解即x0
             A=p2+1.0*a*a*q2/(b*b);
             B=p1-2.0*a*c*q2/(b*b)-1.0*a*q1/b;
             C=1.0*q2*c*c/(b*b)+1.0*q1*c/b;
             t=-B/(2.0*A);//化简后得到的函数的对称轴
             ubt=(t-x)/b;//通解：x=x0+b*k ----> t=x0+b*ubt ----> 倍数ubt=(t-x0)/b
             for(LL i=ubt-;i<=ubt+;++i){//枚举倍数ubt的上下几个值即可
                 LL x1=x+b*i;//通解：x=x0+b*i
                 LL y1=(c-a*x1)/b;
                 ans=min(ans,f(x1,y1));
             }
             cout<<ans<<endl;
         }
     }
     return ;
 }

E.Eustia of the Tarnished Wings

题目描述

Novus Aither是一个潜藏着多个势力的城市。每个势力都有一个唯一的领导人，每个领导人有一个属性值。如果两个势力的领导人的属性值分别为a,b，且|a-b| ≤ m，说明这两个领导人的思想有一定的相似之处，这两个势力可以合并，新的领导人可以指定为原来的两个领导人中的任意一个。新产生的势力可以依照相同的规则，继续与其他势力合并。问在所有可能的情况中，最少会剩下几个势力。

输入描述:

第一行两个空格隔开的整数n(1 ≤ n ≤ 10^6),m(0 ≤ m ≤ 10^9)。n代表当前势力的个数。m的含义如题目描述。

第二行n个空格隔开的整数di(0 ≤ di ≤ 10^9)，代表第i个势力的领导人的属性值。

输出描述:

输出一个数表示势力的最少数量。

输入例子:

4 1
2 1 3 10

输出例子:

2

-->

示例1

输入

4 1
2 1 3 10

输出

2
解题思路：简单贪心，排个序，每次取最大的一个-->后者，符合前后两个属性值之差不大于m的个数为cnt，那么剩下势力的最少数量为n-cnt。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const int maxn=1e6+;
 int n,m,cnt,a[maxn];
 int main(){
     while(cin>>n>>m){
         for(int i=;i<n;++i)cin>>a[i];
         sort(a,a+n);cnt=;
         for(int i=;i<n;++i)
             if(a[i]-a[i-]<=m)cnt++;
         cout<<n-cnt<<endl;
     }
     return ;
 }

L.New Game!

题目描述

Eagle Jump公司正在开发一款新的游戏。Hifumi Takimoto作为其中的员工，获得了提前试玩的机会。现在她正在试图通过一个迷宫。
这个迷宫有一些特点。为了方便描述，我们对这个迷宫建立平面直角坐标系。迷宫中有两条平行直线 L₁:Ax+By+C₁=0, L₂:Ax+By+C₂=0，还有 n 个圆$ C_i : (x - x_i)^2 + (y - y_i)^2 = r_i^2 $ 。角色在直线上、圆上、园内行走不消耗体力。在其他位置上由S点走到T点消耗的体力为S和T的欧几里得距离。
Hifumi Takimoto想从 L₁ 出发，走到 L₂ 。请计算最少需要多少体力。

输入描述:

第一行五个正整数 n,A,B,C1,C2(1≤ n ≤ 1000, -10000 ≤ A,B,C1,C2 ≤ 10000)，其中 A,B 不同时为 0。

接下来 n 行每行三个整数 x,y,r(-10000 ≤ x,y ≤ 10000, 1≤ r ≤ 10000) 表示一个圆心为 (x,y)，半径为 r 的圆。

输出描述:

仅一行一个实数表示答案。与正确结果的绝对误差或者相对误差不超过 10^(-4) 即算正确。

输入例子:

2 0 1 0 -4
0 1 1
1 3 1

输出例子:

0.236068

-->

示例1

输入

2 0 1 0 -4
0 1 1
1 3 1

输出

0.236068
解题思路：求直线L1到直线L2间需要越过的空白距离的最小值，dp一下即可。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=;
 struct cyc{double x,y,r,dis1,dis2;}arr[maxn];
 bool cmp(cyc a,cyc b){return a.dis1<b.dis1;}
 int n;double A,B,C1,C2,ans,dp[maxn];
 int main(){
     while(cin>>n>>A>>B>>C1>>C2){
         for(int i=;i<n;++i){
             cin>>arr[i].x>>arr[i].y>>arr[i].r;
             arr[i].dis1=fabs(A*arr[i].x+B*arr[i].y+C1)/sqrt(A*A+B*B);//求出每个圆心到直线L1的距离
             arr[i].dis2=fabs(A*arr[i].x+B*arr[i].y+C2)/sqrt(A*A+B*B);//求出每个圆心到直线L2的距离
         }
         sort(arr,arr+n,cmp);ans=fabs(C1-C2)/sqrt(A*A+B*B);//最少需要消耗的体力为两直线间的距离
         for(int i=;i<n;++i){
             dp[i]=max(arr[i].dis1-arr[i].r,0.0);//先初始化到直线L1的空白距离-->非负数
             for(int j=;j<i;++j)//再处理两直线的中间所有圆之间的空白最短的距离
                 dp[i]=min(dp[i],dp[j]+max(0.0,sqrt((arr[i].x-arr[j].x)*(arr[i].x-arr[j].x)+(arr[i].y-arr[j].y)*(arr[i].y-arr[j].y))-(arr[i].r+arr[j].r)));
             ans=min(ans,dp[i]+max(0.0,arr[i].dis2-arr[i].r));//最后处理当前的一个圆到直线L2的空白距离-->非负数
         }
         cout<<setiosflags(ios::fixed)<<setprecision()<<ans<<endl;
     }
     return ;
 }

Day_2

A.矩阵乘法

题目描述

深度学习算法很大程度上基于矩阵运算。例如神经网络中的全连接，本质上是一个矩阵乘法；而卷积运算也通常是用矩阵乘法来完成的。有一些科研工作者为了让神经网络的计算更快捷，提出了二值化网络的方法，就是将网络权重压缩成只用两种值表示的形式，这样就可以用一些 trick 加速计算了。例如两个二进制向量点乘，可以用计算机中的与运算代替，然后统计结果中 1 的个数即可。

然而有时候为了降低压缩带来的误差，只允许其中一个矩阵被压缩成二进制。这样的情况下矩阵乘法运算还能否做进一步优化呢？给定两个整数矩阵A, B，计算矩阵乘法 C = A x B。为了减少输出，你只需要计算 C 中所有元素的的异或和即可。

输入描述:

第一行有三个整数 N, P, M, 表示矩阵 A, B 的大小分别是 N x P, P x M 。
接下来 N 行是矩阵 A 的值，每一行有 P 个数字。第 i+1 行第 j 列的数字为 A_i,j, A_i,j

用大写的16进制表示（即只包含 0~9, A~F），每个数字后面都有一个空格。
接下来 M 行是矩阵 B 的值，每一行是一个长为 P 的 01字符串。第 i + N + 1 行第 j 个字符表示 B_j,i的值。

输出描述:

一个整数，矩阵 C 中所有元素的异或和。

输入例子:

4 2 3
3 4
8 A
F 5
6 7
01
11
10

输出例子:

2

-->

示例1

输入

4 2 3
3 4
8 A
F 5
6 7
01
11
10

输出

2

说明

矩阵 C 的值为：
4 7 3
10 18 8
5 20 15
7 13 6

备注:

2 ≤ N, M ≤ 4096, 1 ≤ P ≤ 64, 0 ≤ A_i,j < 65536.
解题思路：01矩阵，预处理一下即可。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 int n,p,m,btr,ans,tmp,a[][],b[][],c[][][],d[][];char str[];
 int main(){
     while(~scanf("%d%d%d",&n,&p,&m)){
         for(int i=;i<n;++i)
             for(int j=;j<p;++j)
                 scanf("%x",&a[i][j]);
         for(int j=;j<m;++j){
             scanf("%s",str);
             for(int i=;i<p;++i)
                 b[i][j]=str[i]-'';
         }
         btr=p/+(p%?:),ans=;//p最多为64，将其分成p/8块，每块8个且有2^8=256种情况
         for(int i=;i<n;++i){//将A矩阵的列进行分块，预处理一下每块对应的256种情况
             for(int j=;j<btr;++j){//块数
                 for(int k=;k<;++k){//对应每块有0~255种情况
                     c[i][j][k]=;//c[i][j][k]表示A矩阵中第i行第j块中第k种情况（二进制为k中bit位为1）的值为累加第i行第j块中bit为x对应的值
                     for(int x=;x<;++x)
                         if(k&(<<x))c[i][j][k]+=a[i][j*+x];
                 }
             }
         }
         for(int j=;j<m;++j){//将矩阵B的行进行分块，统计每块中的每一列的二进制串代表的整数
             for(int i=;i<btr;++i){
                 d[i][j]=;//d[i][j]表示第i块第j列对应的整数
                 for(int k=;k<;++k)
                     d[i][j]+=b[i*+k][j]<<k;
             }
         }
         for(int i=;i<n;++i){//利用预处理的结果，将对应的块中相乘的值加起来
             for(int j=;j<m;++j){
                 tmp=;
                 for(int k=;k<btr;++k)
                     tmp+=c[i][k][d[k][j]];
                 ans^=tmp;
             }
         }
         printf("%d\n",ans);
     }
     return ;
 }

F.平衡二叉树

题目描述

平衡二叉树，顾名思义就是一棵“平衡”的二叉树。在这道题中，“平衡”的定义为，对于树中任意一个节点，都满足左右子树的高度差不超过 d. 空树的高度定义为0，单个节点的高度为1，其他情况下树的高度定义为根节点左右子树高度最大值 + 1. 一棵在高度上平衡的树，节点数可能不平衡，因此再定义一棵树的不平衡度为这棵树中所有节点的左右子树的节点数之差的最大值。
给定平衡的定义参数d, 你需要求出所有高度为 n 的平衡树中不平衡度的最大值。

输入描述:

两个整数，n, d.

输出描述:

一个整数：所有高度为 n 的平衡树中不平衡度的最大值。

输入例子:

4 1

输出例子:

5

-->

示例1

输入

4 1

输出

5

说明

下面这棵树在 d=1 的定义下高度是平衡的，其不平衡度为 5。

备注:

0 ≤ n, d ≤ 60.
解题思路：看代码。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;LL n,d,dp[];
 int main(){//dp[i]表示根节点的右子树中高度为i，平衡因子为d的当前节点所拥有的子节点（包括自己）的总个数
     while(cin>>n>>d){
         memset(dp,,sizeof(dp));
         for(LL i=;i<=n--d;++i){//根节点的右子树最大高度为n-1-d，从右子树的叶子节点往上统计
             if(i>d)dp[i]=dp[i-]+dp[i--d]+;//每层最多一个节点，如果当前节点的高度大于d，那么其包含节点的总个数为本身1+左子节点i-1拥有的节点数量+高度差为d右子节点i-1-d拥有的节点数量
             else dp[i]=i;//否则为子节点的数量加上本身dp[i-1]+1即i
         }
         cout<<(1LL<<(n-))--dp[max(n--d,0LL)]<<endl;//根节点的左子数为满二叉树
     }
     return ;
 }

H.卡牌游戏

题目描述

小贝喜欢玩卡牌游戏。某个游戏体系中共有N种卡牌，其中M种是稀有的。小贝每次和电脑对决获胜之后都会有一个抽卡机会，这时系统会随机从N种卡中选择一张给小贝。普通卡可能多次出现，而稀有卡牌不会被重复抽到。小贝希望收集到K种稀有卡牌，她想知道期望需要多少次获胜才能实现这个目标。

输入描述:

数据有多组，第一行一个整数T表示数据组数。
每组数据一行，三个整数N,M,K .

输出描述:

对于每组数据，输出形如"Case #x: y"，其中 x 为这组数据的编号（从1开始），y 为这组数据的答案。答案的绝对误差或相对误差在10^(-6)以内都认为是正确的。

输入例子:

2
5 2 1
40 9 5

输出例子:

Case #1: 2.5
Case #2: 28.1146825397

-->

示例1

输入

2
5 2 1
40 9 5

输出

Case #1: 2.5
Case #2: 28.1146825397

备注:

1 ≤ T ≤ 100
1 ≤ N ≤ 10^5

1 ≤ M ≤ N
1 ≤ K ≤ M
解题思路：简单推导，假设第x次抽到稀有卡牌中的某一种（张），那么有x*m/n=1（1为只有一张），即x=n/m，那么总的期望次数就是∑j=0k-1(n-j)/(m-j)。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 int t,k;double ans,n,m;
 int main(){
     while(cin>>t){
         for(int i=;i<=t;++i){
             cin>>n>>m>>k;ans=;
             for(int j=;j<k;++j)ans+=(n-j)/(m-j);
             cout<<"Case #"<<i<<": "<<setiosflags(ios::fixed)<<setprecision()<<ans<<endl;
         }
     }
     return ;
 }

Day_3

A.Knight

题目描述

有一张无限大的棋盘，你要将马从(0,0)移到(n,m)。
每一步中，如果马在(x,y)，你可以将它移动到(x+1,y+2),(x+1,y-2),(x-1,y+2),(x-1,y-2),(x+2,y+1),(x+2,y-1),(x-2,y+1)或(x-2,y-1)。
你需要最小化移动步数。

输入描述:

第一行一个整数t表示数据组数 (1≤ t≤ 1000)。
每组数据一行两个整数n,m (|n|,|m|≤ 10^9)。

输出描述:

每组数据输出一行一个整数表示最小步数。

输入例子:

2
0 4
4 2

输出例子:

2
2

-->

示例1

输入

2
0 4
4 2

输出

2
2
解题思路：由于棋盘非常大，先bfs打表找一下规律。

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=;
 int t,n,m,cnt,mp[maxn][maxn],dir[][]={{,},{,-},{-,},{-,-},{,},{,-},{-,},{-,-}};
 bool vis[maxn][maxn];
 struct node{int x,y,step;}nod;
 queue<node> que;
 void bfs(int x,int y){
     while(!que.empty())que.pop();
     memset(vis,false,sizeof(vis));
     mp[nod.x=x][nod.y=y]=nod.step=;vis[x][y]=true;
     que.push(nod);
     while(!que.empty()){
         nod=que.front();que.pop();
         if(!nod.x&&!nod.y){cout<<nod.step<<endl;return;}
         for(int i=;i<;++i){
             node next=nod;
             next.x+=dir[i][];
             next.y+=dir[i][];
             next.step++;
             if(!next.x&&!next.y){cout<<next.step<<endl;return;}
             if(next.x>=&&next.y>=&&next.x<&&next.y<&&!vis[next.x][next.y]){
                 vis[next.x][next.y]=true;
                 mp[next.x][next.y]=next.step;
                 que.push(next);
             }
         }
     }
 }
 int main(){
     while(cin>>t){
         while(t--){
             cin>>n>>m;
             bfs(n,m);
             for(int i=;i<n+m;++i)
                 for(int j=;j<n+m;++j)
                     cout<<mp[i][j]<<(j==n+m-?'\n':' ');
         }
     }
     return ;
 }

打完表之后发现数据是成中心对称的，且第一象限内又关于直线y=x对称，所以预处理一下½的数据即可，如图：

由图可知：在直线L2下面部分，每个数字都有4层，而夹在直线L1和直线L2之间的数据只有3层，除了两个特殊的坐标点外：（1，0）---> 3步、（2，1）---> 4步，手推找规律：①当点（n，m）(n始终处理成大于或等于m)在直线L2下面包括在直线L2上时，即m≤n/2 ---> 2*m≤n，step=n-m-2*floor((n-2*m)/4.0)；②当点（n，m）（n始终处理成大于或等于m）处在直线L1和直线L2之间时，即2*m>n，step=n-m-2*floor((n-2*m)/3.0)。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 int t,n,m,step;
 int main(){
     while(cin>>t){
         while(t--){
             cin>>n>>m;
             n=abs(n),m=abs(m);step=;
             if(n<m)swap(n,m);//处理为第一象限的1/2部分
             if(n==&&!m)step=;
             else if(n==&&m==)step=;
             else{
                 if(*m>n)step=n-m-*floor((n-*m)/3.0);
                 else step=n-m-*floor((n-*m)/4.0);
             }
             cout<<step<<endl;
         }
     }
     return ;
 }

D.Shopping

题目描述

你要买n件物品，其中有一些是凳子。
商场正在举行促销活动，如果购物车中有至少一个凳子，那么你可以半价购买这个购物车中最贵的一个物品。
你有m辆购物车，请最小化你的花费。

输入描述:

第一行一个整数t表示数据组数 (1 ≤ t ≤ 100)。
每组数据第一行两个整数n,m (1 ≤ n,m ≤ 1000)，接下来n行每行两个整数a_i,b_i，分别表示第i件物品的价格以及它是否是凳子 (1 ≤ a_i ≤ 10^5, 0 ≤ b_i ≤ 1)。

输出描述:

每组数据输出一行一个实数表示最小花费，保留一位小数。

输入例子:

2
5 1
1 0
2 1
3 1
4 0
5 0
5 10
1 0
2 1
3 1
4 0
5 0

输出例子:

12.5
10.5

-->

示例1

输入

2
5 1
1 0
2 1
3 1
4 0
5 0
5 10
1 0
2 1
3 1
4 0
5 0

输出

12.5
10.5
解题思路：将物品价格从小到大排序，从后往前取min(num,m)个物品的一半价格+剩下物品的总价格即可。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const int maxn=1e5+;
 int t,n,m,num,a[maxn],b;double sum;
 int main(){
     while(cin>>t){
         while(t--){
             cin>>n>>m;num=;sum=0.0;
             for(int i=;i<n;++i){
                 cin>>a[i]>>b;
                 if(b)num++;
                 sum+=a[i];
             }
             sort(a,a+n);
             for(int i=;i<=num&&i<=m;++i)sum-=a[n-i]/2.0;
             cout<<setiosflags(ios::fixed)<<setprecision()<<sum<<endl;
         }
     }
     return ;
 }

H.Travel

题目描述

魔方国有n座城市，编号为1～n。城市之间通过n-1条无向道路连接，形成一个树形结构。
澜澜打算在魔方国进行m次旅游，每次游览至少一座城市。为了方便，每次旅游游览的城市必须是连通的。此外，澜澜希望游览所有城市恰好一次。
澜澜想知道有多少种旅游方案满足条件，两个方案不同当且仅当存在某一次旅游游览了不同的城市。
澜澜不会数数，所以只好让你来帮他数方案。

输入描述:

第一行一个整数t表示数据组数 (1 ≤ t ≤ 100)。
每组数据第一行两个整数n,m (1 ≤ m ≤ n ≤ 10^5, ∑n ≤ 10^6)，接下来n-1行每行两个整数a_i,b_i表示一条道路 (1≤ a_i,b_i ≤ n)。

输出描述:

每组数据输出一行一个整数表示方案数对1e9+7取模的结果。

输入例子:

2
3 1
1 2
1 3
3 2
1 2
1 3

输出例子:

1
4

-->

示例1

输入

2
3 1
1 2
1 3
3 2
1 2
1 3

输出

1
4
解题思路：澜澜将在魔方国中进行m次旅行，要求魔方国的n座城市恰好全部被浏览一次，这就相当于在n-1个空中放m-1块隔板将n座城市划分成m块，由于块与块之间浏览的次序不同造成更多的方案数，因此还需乘上m！。公式：C(n-1,m-1)*m!%mod。组合数取模大质数-->乘法逆元+费马小定理快速求解即可。
AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const LL mod=1e9+;
 const int maxn=1e5+;
 LL t,n,m,a,b,fac[maxn]={};
 LL quick_pow(LL a,LL b,LL mod){
     LL ans=;
     while(b){
         if(b&)ans=ans*a%mod;
         a=a*a%mod;
         b>>=;
     }
     return ans;
 }
 int main(){
     for(LL i=;i<maxn;++i)fac[i]=fac[i-]*i%mod;
     while(cin>>t){
         while(t--){
             cin>>n>>m;
             for(int i=;i<n;++i)cin>>a>>b;
             cout<<fac[m]*fac[n-]%mod*quick_pow(fac[m-]*fac[n-m]%mod,mod-,mod)%mod<<endl;
         }
     }
     return ;
 }