程序设计思维与实践 Week6 限时大模拟

A - 掌握魔法の东东 II

从瑞神家打牌回来后，东东痛定思痛，决定苦练牌技，终成赌神！
东东有 A × B 张扑克牌。每张扑克牌有一个大小(整数，记为a，范围区间是 0 到 A - 1）和一个花色（整数，记为b，范围区间是 0 到 B - 1。
扑克牌是互异的，也就是独一无二的，也就是说没有两张牌大小和花色都相同。
“一手牌”的意思是你手里有5张不同的牌，这 5 张牌没有谁在前谁在后的顺序之分，它们可以形成一个牌型。 我们定义了 9 种牌型，如下是 9 种牌型的规则，我们用“低序号优先”来匹配牌型，即这“一手牌”从上到下满足的第一个牌型规则就是它的“牌型编号”（一个整数，属于1到9）：

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

现在, 东东从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

思路
将刚开始的两张牌单独拿出来，目前手里已经有两张牌。

然后其他的牌按照a的大小顺序存储在牌集合里面。这样枚举的时候能够保证每次取出的三张牌都是按a的大小升序的。

然后每次枚举三张牌 ，这三张牌按照a的大小升序放入东东手中。

开始计算。计算的时候把这五张牌的a值都存放在一个int型数组te中，进行sort升序排序 。

用二分找到相同大小的牌的个数，存放在equ数组中，就是equ[i]表示有i张牌大小相同的情况有多少 。比如说equ[2]=2就是说五张牌中有两对

接下来进行判断。

1. 同花顺：花色即五张牌的b相同并且te数组中te[i]+1==te[i+1]对每一个0<=i<n-1都满足。
2. 炸弹：有四张牌大小相等，即equ[4]=1
3. 三带二：即equ[3]=1并且equ[2]=1
4. 同花：即五张牌的b相同
5. 顺子：即te数组中te[i]+1==te[i+1]对每一个0<=i<n-1都满足
6. 三条：即equ[3]=1
7. 两对：即equ[2]=2
8. 一对：即equ[1]=1
9. 要不起：即其他情况

据此可写出下面的代码

代码

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

struct cards
{
	int a;
	int b;

	cards()
	{
		a = b = -1;
	}

	cards& operator=(const cards& rv)
	{
		a = rv.a;
		b = rv.b;
		return *this;
	}

	bool operator ==(const cards& rv)
	{
		return (a == rv.a && b == rv.b);
	}
};

struct type
{
	cards c1;
	cards c2;
	cards c3;

	type(){	}

	type(cards c1, cards c2, cards c3)
	{
		this->c1.a = c1.a;
		this->c1.b = c1.b;

		this->c2.a = c2.a;
		this->c2.b = c2.b;
		
		this->c3.a = c3.a;
		this->c3.b = c3.b;
	}

	bool operator ==(const type& rv)
	{
		if (c1 == rv.c1 && c2 == rv.c2 && c3 == rv.c3)
		{
			return true;
		}
		
		return false;
		
	}

	bool operator < (const type & rv)const
	{//这里可以不要。
		if (c1.a != rv.c1.a)return c1.a < rv.c1.a;
		if (c2.a != rv.c2.a)return c2.a < rv.c2.a;
		return c3.a < rv.c3.a;

		return false;
	}
};

cards c[110];
int sum[10] = { 0 };
cards cr1;
cards cr2;



//找到>=x的第一个位置
int findOne(int& x, int* sum, int n)
{
	int left = 0, right = n;
	while (left < right)
	{
		int mid = (left + right) >> 1;
		if (sum[mid] >= x)
		{
			right = mid;
		}
		else
		{
			left = mid + 1;
		}
	}

	if (sum[left] != x)
	{
		return -1;
	}
	else
	{
		return left;
	}
}

//找到x的最后一个位置
int findEnd(int& x, int* sum, int n)
{
	int left = 0, right = n;
	while (left < right)
	{
		int mid = (right + left) >> 1;
		if (sum[mid] > x)
		{
			right = mid;
		}
		else
		{
			left = mid + 1;
		}
	}
	return left;
}

void calculate(type& a)
{
	int te[5] = { cr1.a,cr2.a,a.c1.a,a.c2.a,a.c3.a };
	sort(te, te + 5);//从小到大排序，判断是否是顺子

	int equ[6] = { 0 };
	for (int i = 0; i < 5; i++)//统计大小相等的牌的个数
	{
		int flag1 = findOne(te[i], te, 5);
		int flag2 = findEnd(te[i], te, 5);

		equ[flag2 - flag1]++;

		i = flag2 - 1;
	}

	if ((cr1.b == cr2.b && cr2.b == a.c1.b && a.c1.b == a.c2.b && a.c2.b == a.c3.b)&&(te[0]+1==te[1]&& te[1] + 1 == te[2]&& te[2] + 1 == te[3]&& te[3] + 1 == te[4]))
	{//同花色并且是顺子
		sum[1]++;
	}
	else if (equ[4] == 1)
	{//有四张牌大小相等，即是炸弹
		sum[2]++;
	}
	else if (equ[3] == 1 && equ[2] == 1)
	{//三带二
		sum[3]++;
	}
	else if (cr1.b == cr2.b && cr2.b == a.c1.b && a.c1.b == a.c2.b && a.c2.b == a.c3.b)
	{//同花色
		sum[4]++;
	}
	else if (te[0] + 1 == te[1] && te[1] + 1 == te[2] && te[2] + 1 == te[3] && te[3] + 1 == te[4])
	{//顺子
		sum[5]++;
	}
	else if (equ[3] == 1)
	{//有三张牌大小相等
		sum[6]++;
	}
	else if (equ[2] == 2)
	{//两对
		sum[7]++;
	}
	else if (equ[2] == 1)
	{//一对
		sum[8]++;
	}
	else
	{//其他
		sum[9]++;
	}

}




int main()
{
	int A, B;
	cin >> A >> B;

	cin >> cr1.a >> cr1.b;
	cin >> cr2.a >> cr2.b;

	//初始化
	int n = 0;
	for (int i = 0; i < A; i++)
	{
		for (int j = 0; j < B; j++)
		{
			if ((i == cr1.a && j == cr1.b) || (i == cr2.a && j == cr2.b))
			{
				continue;
			}
			else
			{
				c[n].a = i;
				c[n].b = j;
				n++;
			}
		}
	}

	
	for (int i = 0; i < n; i++)//选第一张牌
	{
		for (int j = i + 1; j < n; j++)//选第二张牌
		{
			for (int k = j + 1; k < n; k++)//选第三张牌
			{
				if (i == j || i == k || j == k)//不能选择相同的牌
				{
					continue;
				}
				else
				{
				
					
					type temp;
					temp.c1 = c[i];
					temp.c2 = c[j];
					temp.c3 = c[k];
					
					
					calculate(temp);
					

				}
			}
		}
	}

	for (int i = 1; i < 10; i++)
	{
		cout << sum[i] << " ";
	}



}