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

A - 掌握魔法の东东 II

题目描述

从瑞神家打牌回来后，东东痛定思痛，决定苦练牌技，终成赌神！
东东有 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

Output

输出一行，这行有 9 个整数，每个整数代表了 9 种牌型的方案数（按牌型编号从小到大的顺序）

Sample Input 1

5 2
1 0 3 1

Sample Output 1

0 8 0 0 0 12 0 36 0

Sample Input 2

25 4
0 0 24 3

Sample Output 2

0 0 0 2 18 1656 644 36432 113344

题解

• 流程
  • 进行dfs遍历，得到所有5张牌的所有组合
  • 对每一种组合进行判断
    • 判断的实现：从1至8依次判断，都不是最后返回9
      • 1：如果2成立且3成立
      • 2：用bool记录是否有相邻项不满足 x[i] == x[i-1]+1
      • 3：用bool记录是否有相邻项花色不相同
      • 4：进行排序，4种花色相同的可能只能是前四张或者后四张两个if即可
      • 5：排序后，3张牌大小相等的情况只有3种，3个if判断属于哪一种，然后也就知道了剩下两张的位置，再判断一下
      • 6：排序后，3张牌大小相等的情况只有4种，4个if判断属于哪一种，然后也就知道了剩下三张的位置，枚举一下两个的情况，再判断一下
      • 7：运用5的前半部分的判断
      • 8：运用6的前半部分的判断
    • 是哪一类牌哪一类的答案就加一
• 最后输出记录的9类数量

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;

typedef long long LL;
int A, B;
int a[30], b[10];
LL ans[15];
bool vis[30][10];

int sortArr[10];
bool rule2() {
	for (int i = 1; i <= 5; ++i)
		sortArr[i] = a[i];
	sort(sortArr+1,sortArr+6);
	int flag = true;
	for (int i = 2; i <= 5; ++i) {
		if (sortArr[i] != (sortArr[i-1]+1)) {
			flag = false;
			break;
		}
	}
	return flag;
}

bool rule3() {
	bool flag = true;
	for (int i = 2; i <= 5; ++i) {
		if (b[i] != b[i-1]) {
			flag = false;
			break;
		}
	}
	return flag;
}

bool rule4() {
	int flag1 = true;
	for (int i = 2; i <= 4; ++i) {
		if (sortArr[i] != (sortArr[i-1])) {
			flag1 = false;
			break;
		}
	}
	int flag2 = true;
	for (int i = 3; i <= 5; ++i) {
		if (sortArr[i] != (sortArr[i-1])) {
			flag2 = false;
			break;
		}
	}
//	if(flag1 || flag2) {
//		for(int i = 1; i <= 5; ++i) {
//			cout << a[i] << ",";
//		}
//		cout << endl;
//	}
	
//	if (a[3] == 24 && a[4] == 24 && a[5] == 24) {
//		cout << flag1 << " and " << flag2 << endl;
//		for(int i = 1; i <= 5; ++ i) {
//			cout << sortArr[i] << ",";
//		}
//		cout << endl;
//	}
	
	return flag1 || flag2;
}

bool rule5() {
	int threeBegin = -1;
	if ((sortArr[1] == sortArr[2]) && 
		(sortArr[2] == sortArr[3])) {
		threeBegin = 1;
	}
	if ((sortArr[2] == sortArr[3]) && 
		(sortArr[3] == sortArr[4])) {
		threeBegin = 2;
	}
	if ((sortArr[3] == sortArr[4]) && 
		(sortArr[4] == sortArr[5])) {
		threeBegin = 3;
	}
	if (threeBegin == 1) {
		return sortArr[4] == sortArr[5];
	} else if (threeBegin == 2) {
		return sortArr[1] == sortArr[5];
	} else if (threeBegin == 3) {
		return sortArr[1] == sortArr[2];
	}
	return false;
}

bool rule6() {
	int twoBegin = -1;
	if (sortArr[1] == sortArr[2]) {
		twoBegin = 1;
	}
	if (sortArr[2] == sortArr[3]){
		twoBegin = 2;
	}
	if (sortArr[3] == sortArr[4]) {
		twoBegin = 3;
	}
	if (sortArr[4] == sortArr[5]) {
		twoBegin = 4;
	}
	if (twoBegin == 1) {
		return (sortArr[3] == sortArr[4]) ||
				(sortArr[4] == sortArr[5]);
	} else if (twoBegin == 2) {
		return (sortArr[4] == sortArr[5]);
	} else if (twoBegin == 3) {
		return (sortArr[1] == sortArr[2]);
	} else if (twoBegin == 4) {
		return (sortArr[1] == sortArr[2]) ||
				(sortArr[2] == sortArr[3]);
	}
	return false;
}

bool rule7() {
	int threeBegin = -1;
	if ((sortArr[1] == sortArr[2]) && 
		(sortArr[2] == sortArr[3])) {
		threeBegin = 1;
	}
	if ((sortArr[2] == sortArr[3]) && 
		(sortArr[3] == sortArr[4])) {
		threeBegin = 2;
	}
	if ((sortArr[3] == sortArr[4]) && 
		(sortArr[4] == sortArr[5])) {
		threeBegin = 3;
	}
	return threeBegin != -1;
}

bool rule8() {
	int twoBegin = -1;
	if (sortArr[1] == sortArr[2]) {
		twoBegin = 1;
	}
	if (sortArr[2] == sortArr[3]){
		twoBegin = 2;
	}
	if (sortArr[3] == sortArr[4]) {
		twoBegin = 3;
	}
	if (sortArr[4] == sortArr[5]) {
		twoBegin = 4;
	}
	return twoBegin != -1;
}

int check() {
	bool rule2res = rule2();
	bool rule3res = rule3();
	if (rule2res && rule3res) return 1;
	if (rule2res) return 2;
	if (rule3res) return 3;
	if (rule4()) return 4;
	if (rule5()) return 5;
	if (rule6()) return 6;
	if (rule7()) return 7;
	if (rule8()) return 8;
	return 9;
}

void dfs(int nowa, int nowb, int cnt) {
	a[cnt] = nowa; b[cnt] = nowb;
	 
//	cout << "nowPEEK:";
//	for (int i = 1; i <= cnt; ++ i) {
//		cout << "(" << a[i] << "," << b[i] << ") ";
//	}

	if(cnt == 5) {
		int res = check();
		ans[res] ++;
		
		if (a[3] == 24 && a[4] == 24 && a[5] == 24 && cnt == 5) {
//			cout << " *" << res << endl;
		}
		
//		cout << " *" << res << endl;
		return;
	}
//	cout << endl;
	if (nowb < B-1) {
		int i = nowa;
		for (int j = nowb+1; j < B; j++) {
			if (vis[i][j]) continue;
			vis[i][j] = 1;
			dfs(i, j, cnt+1);
			vis[i][j] = 0;
		}
	}
	for (int i = nowa+1; i < A; i++) {
		for (int j = 0; j < B; j++) {
			if (vis[i][j]) continue;
			vis[i][j] = 1;
			dfs(i, j, cnt+1);
			vis[i][j] = 0;
		}
	}
}

int main() {
	cin >> A >> B;
	cin >> a[1] >> b[1] >> a[2] >> b[2];
	vis[a[1]][b[1]] = vis[a[2]][b[2]] = 1;
	
	for (int i = 0; i < A; i++) {
		for (int j = 0; j < B; j++) {
			if (vis[i][j]) continue;
			vis[i][j] = 1;
			dfs(i, j, 3);
			vis[i][j] = 0;
		}
	}
	
	for(int i = 1; i <= 9; ++i) {
		cout << ans[i] << " ";
	}
	cout << endl;
	return 0;
}