掌握魔法の东东 II Gym-270437

题目
从瑞神家打牌回来后，东东痛定思痛，决定苦练牌技，终成赌神！
东东有 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 种牌型的方案数（按牌型编号从小到大的顺序）

Examples
input
5 2
1 0 3 1
output
0 8 0 0 0 12 0 36 0

input
25 4
0 0 24 3
output
0 0 0 2 18 1656 644 36432 113344

解题思路
题目很长，我们需要求出9种牌的组合数。

1.每一种组合我们最好就是9种情况都比较过，这样每种组合就只需要遍历一次。

2.最好用一个数组来储存每一种牌的数量，这样比较好进行数量的比较。

代码实现

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int A,B,a1,a2,b1,b2;
struct pai{   //牌的结构体
	int a,b;
	bool operator<(const pai &p)
	{
		if(a!=p.a)  return a<p.a;
		else return b<p.b;
	}
};
pai p[150];int pi;
int sum[10];  //每种多少组 
pai ppp[5];   //一组牌
void add(int i,int j)   //加牌 
{
	pai p1;p1.a=i,p1.b=j;
	p[pi++]=p1;
}

pai a_,b_;
bool _2(pai i,pai j,pai k)   //顺子 
{
	ppp[0]=a_,ppp[1]=b_,ppp[2]=i,ppp[3]=j,ppp[4]=k;
	sort(ppp,ppp+5);
	int x = ppp[0].a;
	for(int g=0;g<5;g++)
	{
		if(x!=ppp[g].a) return 0;
		x++; 
	}
	return 1;
}
bool _3(pai i,pai j,pai k)  //同花 
{
	ppp[0]=a_,ppp[1]=b_,ppp[2]=i,ppp[3]=j,ppp[4]=k;
	for(int l=0;l<4;l++)
	{
		if( ppp[l].b !=ppp[l+1].b )  return 0;
	}
	return 1;
}
bool _456789(pai i,pai j,pai k)  
{
	ppp[0]=a_,ppp[1]=b_,ppp[2]=i,ppp[3]=j,ppp[4]=k;
	int c[5];  //装这组牌的大小
	c[0]=a_.a,c[1]=b_.a,c[2]=i.a,c[3]=j.a,c[4]=k.a;
	int count[5];//每种大小的个数
	for(int g=0 ;g<5;g++) count[g]=0;
	for(int g=0;g<5;g++)
	{
		for(int h=0;h<5;h++)
		{
			if( ppp[g].a == c[h] )  count[g]++;
		}
	}
	for(int g=0;g<5;g++)
	{//如果有4张相等
		if(count[g]==4) {sum[4]++;return 1;}   //炸弹 
	}
	bool flag1=0,flag2=0;
	for(int g=0;g<5;g++)
	{
		if(count[g]==3) 
		flag1=1;
		else if(count[g]==2)
		flag2=1;
	}//如果有3张相等，2张相等
	if(flag1 && flag2) {sum[5]++;return 1;}   //三带二 
	int flag=0;
	for(int g=0;g<5;g++)
	{
		if(count[g]==2)          
		flag++;
	}  //如果有2对相等，那么count应该为 2 2 2 2 1
	if(flag == 4)  {sum[6]++;return 1;}   //两对  2 2 2 2 1

	for(int g=0;g<5;g++)
	{
		if(count[g]==3)          
		{sum[7]++;return 1;}        //三条 
	}

	for(int g=0;g<5;g++)
	{
		if(count[g]==2)          
		{sum[8]++;return 1;}        //一对 
	}
	return 0;   //要不起 
} 
int main()
{
	ios::sync_with_stdio(0);
	cin>>A>>B;
	cin>>a1>>b1>>a2>>b2;
	a_.a=a1,a_.b=b1; b_.a=a2,b_.b=b2;
	for(int i=0;i<A;i++)
	{
		for(int j=0;j<B;j++)
		{
			if(i==a1&&j==b1) continue;
			if(i==a2&&j==b2) continue;
			add(i,j);
		}
	}
	for(int i=0;i<pi-2;i++)  //遍历所有组合
	{
		for(int j=i+1;j<pi-1;j++)
		{
			for(int k=j+1;k<pi;k++)
			{
				if( _2(p[i],p[j],p[k]) && _3(p[i],p[j],p[k]) )   //同花顺 
				{
					sum[1]++;continue;
				}
				if(_2(p[i],p[j],p[k]))
				{
					sum[2]++;continue;       //顺子 
				}
				if(_3(p[i],p[j],p[k]))
				{
					sum[3]++;continue;       //同花 
				}
				if(!_456789(p[i],p[j],p[k]))
				{
					sum[9]++;continue; //要不起
				}
			}
		}
	}
	cout<<sum[1];
	for(int i=2;i<=9;i++)
	{
		cout<<" "<<sum[i];
	}
	return 0; 
} 

小结
代码思路不难，但是细节比较多，因为数据不大，对复杂度要求没那么高，还比较好写。
就是要判断的东西太多，一开始不太敢下手。