打牌游戏2

问题描述：

东东有 A × B 张扑克牌。每张扑克牌有一个大小(整数，记为a，范围区间是 0 到 A - 1）和一个花色（整数，记为b，范围区间是 0 到 B - 1。
扑克牌是互异的，也就是独一无二的，也就是说没有两张牌大小和花色都相同。
“一手牌”的意思是你手里有5张不同的牌，这 5 张牌没有谁在前谁在后的顺序之分，它们可以形成一个牌型。 我们定义了 9 种牌型，如下是 9 种牌型的规则，我们用“低序号优先”来匹配牌型，即这“一手牌”从上到下满足的第一个牌型规则就是它的“牌型编号”（一个整数，属于1到9）：
同花顺: 同时满足规则 2 和规则 3.
顺子 : 5张牌的大小形如 x, x + 1, x + 2, x + 3, x + 4
同花 : 5张牌都是相同花色的.
炸弹 : 5张牌其中有4张牌的大小相等.
三带二 : 5张牌其中有3张牌的大小相等，且另外2张牌的大小也相等.
两对: 5张牌其中有2张牌的大小相等，且另外3张牌中2张牌的大小相等.
三条: 5张牌其中有3张牌的大小相等.
一对: 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 种牌型的方案数（按牌型编号从小到大的顺序）

样例输入1：

5 2
1 0 3 1

样例输入2：

25 4
0 0 24 3

样例输出1：

0 8 0 0 0 12 0 36 0

样例输出2：

0 0 0 2 18 1656 644 36432 113344

解题思路：

对于这个题目，我们首先想到的就是枚举，最多有100张牌，已知两张牌，则我们从剩余的98张牌中选三张即可。对于每一张牌，我们都有两种选择，选还是不选，类似于求子集问题。则我们可以通过dfs递归加上剪枝来实现。一张牌的信息通过一个结构体来存储，有点数和花色两个域。

对于每一次递归，我们都要判断现有的牌数是不是5，若不是5，则判断是否是一开始已有的两张牌，若是则跳过这张牌继续递归。若不是，则有两种选择，将这张牌加入现有的牌，不将这张牌加入现有的牌，两种情况分别进行递归。如果牌数为5，则进行每一种情况的判断，从序号小的情况开始判断，如果有一种情况满足，该情况的数目加1，,然后返回。对于每一种情况，则分别有一个函数来进行相应的计算。

代码：

#include<iostream>
using namespace std;
struct poke{ //存储牌的信息
	int num;
	int col;
};
int A,B;	
int a1,b1,a2,b2;
poke pp[101];
int tn[10]={0,0,0,0,0,0,0,0,0,0};	 //每一种情况的数量
bool shunzi(poke po[])
{//是否为顺子
	int minnum=po[1].num;
	for(int i=2;i<=5;i++)
	{
		if(minnum>po[i].num)
			minnum=po[i].num;//找到5张牌中的最小值
	}
	bool temp[5];
	for(int i=0;i<5;i++)	
		temp[i]=false;
	for(int i=1;i<=5;i++)
	{
		int tt=po[i].num-minnum;//每一项分别于最小值相减
		if(tt>4)//如果大于4，则不可能
			return false;
		temp[tt]=true;
	}
	//如果每一项减最小值分别等于0 1 2 3 4 则是顺子
	if(temp[0]&&temp[1]&&temp[2]&&temp[3]&&temp[4])
		return true;
	else 
		return false;
}
bool tonghua(poke po[])
{//是否为同花
	bool tm=true;
	int flag=po[1].col;
	for(int i=2;i<=5;i++)
	{
		if(po[i].col!=flag)//判断每一张牌的花色是否都等于第一张
			tm=false;
	}
	return tm;
}
bool boom(poke po[])
{//判断是否为炸弹
	if(B<4)//如果花色小于4，不可能有炸弹
		return false;
	else
	{
		int temp[A];
		for(int i=0;i<A;i++)
			temp[i]=0;
		for(int i=1;i<=5;i++)
			temp[po[i].num]++;//计算每一张牌出现的次数
		bool zx=false;
		for(int i=0;i<A;i++)
		{
			if(temp[i]==4)//若为4，则是炸弹
				zx=true;
		}
		return zx;
	}
}
bool saner(poke po[])
{//是否是三带二
	if(B<3)
		return false;//如果花色小于3则不可能
	else
	{
		int temp[A];
		for(int i=0;i<A;i++)
			temp[i]=0;
		for(int i=1;i<=5;i++)
			temp[po[i].num]++;//计算每一张牌出现的次数
		bool zx=false;
		bool zx1=false;
		for(int i=0;i<A;i++)
		{
			if(temp[i]==3)
				zx=true;
			else if(temp[i]==2)
				zx1=true;
		}
		if(zx&&zx1) return true;
		else return false;
	}
}
int erdui(poke po[])
{//计算有几对
	int temp[A];
	int nn=0;
	for(int i=0;i<A;i++)
		temp[i]=0;
	for(int i=1;i<=5;i++)
		temp[po[i].num]++;//计算每一张牌的次数
	for(int i=0;i<A;i++)
	{
		if(temp[i]==2)
			nn++;
	}
	return nn;//nn为二对的个数
}
bool santiao(poke po[])
{//判断是否为三条
	if(B<3)
		return false;//如果花色小于3，则不可能为三条
	else
	{
		int temp[A];
		for(int i=0;i<A;i++)
			temp[i]=0;
		for(int i=1;i<=5;i++)
			temp[po[i].num]++;
		bool zx=false;
		bool zx1=false;
		for(int i=0;i<A;i++)
		{
			if(temp[i]==3)
				zx=true;
			else if(temp[i]==2)
				zx1=true;
		}
		if(zx&&!zx1) //与三带二条件不同
			return true;
		else 
			return false;
	}
}
void solve(int pokenum,int now,int total,poke five[])
{//求解函数
	if(now>pokenum) return;//递归终点
	if(total==5)//如果现有牌数为5
	{
		bool nine=true;
		if(shunzi(five))//判断是否为顺子
		{
			if(tonghua(five))//若为顺子，判断是否为同花
				tn[1]++; //两者都满足则为同花顺
			else
				tn[2]++;
			nine=false;
			return;
		}
		if(tonghua(five))
		{//判断是否为同花
			if(shunzi(five))
				tn[1]++;
			else
				tn[3]++;
			nine=false;
			return;
		}
		if(boom(five))
		{//判断是否为炸弹
			nine=false;
			tn[4]++;
			return;
		}	
		if(saner(five))
		{//判断是否为三带二
			tn[5]++;
			nine=false;
			return;
		}	
		int dui=erdui(five);//求二对的个数
		if(dui==2)
		{
			tn[6]++;
			nine=false;
			return;
		} 
		if(santiao(five))
		{//判读是否为三条
			nine=false;
			tn[7]++;
			return;
		}
		if(dui==1)
		{
			tn[8]++;
			nine=false;
			return;
		} 
		
		if(nine==true)
			tn[9]++;//都不满足，要不起
		return ;
	}
	//判断该牌是否为一开始抽到的两张牌，若是，则跳过继续递归
	if((pp[now].num==a1&&pp[now].col==b1)||(pp[now].num==a2&&pp[now].col==b2))
		solve(pokenum,now+1,total,five);
	else
	{
		five[total+1].num=pp[now].num;
		five[total+1].col=pp[now].col;
		solve(pokenum,now+1,total+1,five);//一手牌中加入该牌
		solve(pokenum,now+1,total,five);//不加入该牌
	}
}
int main()
{
	cin>>A>>B;
	int flag=0;
	for(int i=0;i<A;i++)
	{
		for(int j=0;j<B;j++)
		{
			pp[flag].num=i;
			pp[flag].col=j;
			flag++;	
		} 
	}
	cin>>a1>>b1>>a2>>b2;
	poke yis[6];
	yis[1].num=a1;
	yis[1].col=b1;
	yis[2].num=a2;
	yis[2].col=b2;
	int all=A*B;
	solve(all,0,2,yis);
	bool nine=true;
	for(int i=1;i<=9;i++)
	{
		cout<<tn[i];//输出每种情况的次数
		if(i!=9)
			cout<<" ";
	}
		
}