程序设计思维与实践 Week6 限时大模拟--A - 掌握魔法の东东 II

题目

从瑞神家打牌回来后，东东痛定思痛，决定苦练牌技，终成赌神！
东东有 A × B 张扑克牌。每张扑克牌有一个大小(整数，记为a，范围区间是 0 到 A - 1）和一个花色（整数，记为b，范围区间是 0 到 B - 1。

扑克牌是互异的，也就是独一无二的，也就是说没有两张牌大小和花色都相同。

“一手牌”的意思是你手里有5张不同的牌，这 5 张牌没有谁在前谁在后的顺序之分，它们可以形成一个牌型。 我们定义了 9 种牌型，如下是 9 种牌型的规则，我们用“低序号优先”来匹配牌型，即这“一手牌”从上到下满足的第一个牌型规则就是它的“牌型编号”（一个整数，属于1到9）：

同花顺: 同时满足规则 5 和规则 4.
炸弹 : 5张牌其中有4张牌的大小相等.
三带二 : 5张牌其中有3张牌的大小相等，且另外2张牌的大小也相等.
同花 : 5张牌都是相同花色的.
顺子 : 5张牌的大小形如 x, x + 1, x + 2, x + 3, x + 4
三条: 5张牌其中有3张牌的大小相等.
两对: 5张牌其中有2张牌的大小相等，且另外3张牌中2张牌的大小相等.
一对: 5张牌其中有2张牌的大小相等.
要不起: 这手牌不满足上述的牌型中任意一个.

现在, 东东从A × B 张扑克牌中拿走了 2 张牌！分别是 (a1, b1) 和 (a2, b2). （其中a表示大小，b表示花色）

现在要从剩下的扑克牌中再随机拿出 3 张！组成一手牌！！

其实东东除了会打代码，他业余还是一个魔法师，现在他要预言他的未来的可能性，即他将拿到的“一手牌”的可能性，我们用一个“牌型编号（一个整数，属于1到9）”来表示这手牌的牌型，那么他的未来有 9 种可能，但每种可能的方案数不一样。

现在，东东的阿戈摩托之眼没了，你需要帮他算一算 9 种牌型中，每种牌型的方案数。
Input第 1 行包含了整数 A 和 B (5 ≤ A ≤ 25, 1 ≤ B ≤ 4).
第 2 行包含了整数 a1, b1, a2, b2 (0 ≤ a1, a2 ≤ A - 1, 0 ≤ b1, b2 ≤ B - 1, (a1, b1) ≠ (a2, b2)).Output输出一行，这行有 9 个整数，每个整数代表了 9 种牌型的方案数（按牌型编号从小到大的顺序）

Examples

Input

5 2
1 0 3 1

Output

0 0 0 0 8 0 12 36 0

Input

25 4

0 0 24 3

output

0 2 18 0 0 644 1656 36432 113344

做法

数据结构

注意到9个条件中有多个条件跟某个数字出现的次数有关，故可定义一个he数组，并利用其对所属牌型进行判断

struct pai
{
 int a,b;
 bool operator<(const pai &p) const//先按大小排序再按花色排序 
 {
  return a!=p.a?a<p.a:b<p.b;//怎么能忘记return呢 
 }
}p[5],p1[5];//p记录选中的牌，p1记录选中的排好序后的牌
bool xuanze[25][4]={};//记录是否被选到 
int shuzi[25]={};//记录每个数字有多少个 
int sum[9]={};//记录不同牌型的数量 

解法

1、录入已取出的两张牌记录在p中，count记录取出的牌数，更新xuanze和shuzi数组
2、调用递归函数meiju（当前枚举到的元素的行，当前枚举到的元素的列），在p中放满5个元素时转到3，否则转到4
3、将p元素值赋给p1，对p1进行sort，接着根据在往p中放入元素时更新的shuzi数组的值计算he数组，存储不同数字和的个数。接着利用不同牌型的特点，判断枚举的这5张牌所满足的牌型。对相应的牌型对应的sum进行加一操作。
4、根据函数传入的参数知此时枚举到数组第n行的第m张牌，按照枚举顺序下一张该从第n行的第m+1张牌开始枚举，并根据新加入p的牌对shuzi和xuanze数组进行更新，具体枚举及更新步骤如下：

 for(n;n<b;n++)
 {
   if(xuanze[m][n]!=1)
   {
    xuanze[m][n]=1;
    p[count1].a=m;
    p[count1].b=n;
    count1++;    
    shuzi[m]++;
    meiju(m,n);
    count1--;
    xuanze[m][n]=0;
    shuzi[m]--; 
   }  
 }
 for(m=m+1;m<a;m++)
  for(n=0;n<b;n++)//注意for循环的第一个条件用于赋for循环的初值&初始条件 
  {
   if(xuanze[m][n]!=1)
   {
    xuanze[m][n]=1;
    p[count1].a=m;
    p[count1].b=n;
    count1++;    
    shuzi[m]++;
    meiju(m,n);
    count1--;
    xuanze[m][n]=0;
    shuzi[m]--; 
   }
  }

5、枚举结束后考虑到有部分枚举会满足多个牌型条件，导致其在多个数组中出现，所以对包含重复元素的sum，用优先级低减去优先级高的。最后依次输出sum的值。

错误

1、这个题一开始尝试用排列组合解、、、太麻烦了、、、真的数学不好不要尝试、、两个小时都没写出来
2、注意递归调用来枚举时要考虑清楚函数内和函数间参数的变化，如果不好考虑清楚的话可以用循环代替递归：三层循环，每层循环的初始条件都从上一层循环所到位置的后一个开始，防止重复遍历。
3、可将二维数组转变为一维数组存储遍历条件，具体转换为一维数组第i个元素对应二维数组的i/A行i%A列的元素

代码

#include<iostream>
#include<algorithm> 
using namespace std;
struct pai
{
	int a,b;
	bool operator<(const pai &p) const//先按大小排序再按花色排序 
	{
		return a!=p.a?a<p.a:b<p.b;//怎么能忘记return呢 
	}
}p[5],p1[5];
int a,b,a1,a2,b1,b2;
int count1=0;
bool xuanze[25][4]={};//记录是否被选到 
int shuzi[25]={};//记录每个数字有多少个 
int sum[9]={};//记录不同牌型的数量 
int m=0,n=0;
void meiju(int m,int n)
{
//	for(int x=0;x<count1;x++)
//		cout<<p[x].a<<' '<<p[x].b<<' ';
//	cout<<endl;	
	if(count1==5)
	{	
		for(int j=0;j<5;j++)
		{
			p1[j].a=p[j].a;
			p1[j].b=p[j].b;
		}
		sort(p1,p1+5);
//	for(int x=0;x<count1;x++)
//		cout<<p1[x].a<<' '<<p1[x].b<<' ';
//	cout<<endl<<endl;	
		int he[5]={0,0,0,0,0};//记录不同个数的数字个数 
		for(int j=0;j<25;j++)
			he[shuzi[j]]++;
		if(p1[0].a==p1[1].a-1&&p1[1].a==p1[2].a-1&&p1[2].a==p1[3].a-1&&p1[4].a==p1[3].a+1
		&&p1[0].b==p1[1].b&&p1[0].b==p1[2].b&&p1[0].b==p1[3].b&&p1[0].b==p1[4].b)
			sum[0]++;
		if(he[4]!=0)
			sum[1]++;
		if(he[3]!=0&&he[2]!=0)
			sum[2]++;
		if(p1[0].b==p1[1].b&&p1[0].b==p1[2].b&&p1[0].b==p1[3].b&&p1[0].b==p1[4].b)
			sum[3]++;
		if(p1[0].a==p1[1].a-1&&p1[1].a==p1[2].a-1&&p1[2].a==p1[3].a-1&&p1[4].a==p1[3].a+1)
			sum[4]++;
		if(he[3]!=0)
			sum[5]++;
		if(he[2]==2)
			sum[6]++;
		if(he[2]!=0)
			sum[7]++;	
		return;
	}
	for(n;n<b;n++)
	{
			if(xuanze[m][n]!=1)
			{
				xuanze[m][n]=1;
				p[count1].a=m;
				p[count1].b=n;
				count1++;				
				shuzi[m]++;
				meiju(m,n);
				count1--;
				xuanze[m][n]=0;
				shuzi[m]--; 
			}		
	}
	for(m=m+1;m<a;m++)
		for(n=0;n<b;n++)//注意for循环的第一个条件用于赋for循环的初值&初始条件 
		{
			if(xuanze[m][n]!=1)
			{
				xuanze[m][n]=1;
				p[count1].a=m;
				p[count1].b=n;
				count1++;				
				shuzi[m]++;
				meiju(m,n);
				count1--;
				xuanze[m][n]=0;
				shuzi[m]--; 
			}
		}
}
int main()
{
	cin>>a>>b;
	cin>>a1>>b1>>a2>>b2;
	p[count1].a=a1;
	p[count1].b=b1;
	count1++;
	p[count1].a=a2;
	p[count1].b=b2;
	count1++;
	xuanze[a1][b1]=1;
	xuanze[a2][b2]=1;
	shuzi[a1]++;
	shuzi[a2]++;
	meiju(0,0);
	sum[3]-=sum[0];
	sum[4]-=sum[0];
	sum[5]-=sum[2];
	sum[7]-=(sum[2]+sum[6]);
	sum[8]= (a*b-2)*(a*b-3)*(a*b-4)/6-(sum[0]+sum[1]+sum[2]+sum[3]+sum[4]+sum[5]+sum[6]+sum[7]);
		for(int i=0;i<9;i++)
		cout<<sum[i]<<' ';
	cout<<endl;
	return 0;
}