题目
从瑞神家打牌回来后,东东痛定思痛,决定苦练牌技,终成赌神!
东东有 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 种牌型的方案数(按牌型编号从小到大的顺序)
Sample Input1
5 2
1 0 3 1
Sample Output1
0 0 0 0 8 0 12 36 0
Sample Input2
25 4
0 0 24 3
Sample Output2
0 2 18 0 0 644 1656 36432 113344
思路分析
一开始被题目容量吓到了,读了好多遍题,开始着手先用数学方法分析一下,将样例的情况弄明白了。然后就陷在数学思维中出不来了。其实这道题的数据规模不大,最多有100张牌,在两张牌确定的情况下,只需要枚举另外三张牌,三个for循环,数据规模也仅有1e6,完全可以接受。
大概思路:定义一个牌面结构体,按照数值大小排序,这样判断牌型时手里的5张牌已经按顺序排好了,可以减少讨论的情况,避免出错。对于九种牌型的情况,分别定义一个布尔类型的子函数,判断是否符合相关规则即可。
首先用两个for循环遍历A*B全部的情况,除去输入的两张确定的牌其余全部存到tmp的结构体数组中,这样接下来遍历时就不用再考虑重复遍历的情况。
三重for循环枚举时,注意跳过遍历到相同牌面的情况,其余情况分别分配给第3、4、5张牌,排序后调用相关函数判断牌型。
惨痛教训
初始化数组ca_type[]时访问越界,应该是for(int i=0;i<10;i++),结果写成i<=10了,从来没犯过这种错误…可能写代码的时候睡着了??本题暴力枚举已经不易,本地编译输出完全没有问题,结果愣是debug一天…WA数次…
代码
#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
int A,B,a1,b1,a2,b2;
int ca_type[10];//牌型数组,存储每个牌型的方案数
struct card{
int a,b;//大小和花色
bool operator<(const card &c)const{
if(a!=c.a) return a<c.a;
return b<c.b;
}
};
card c[6],tmp[100];//枚举5张牌,除确定的2张牌外所有可能的牌面(数据规模为100)
bool boom()
{//炸弹
if((c[1].a==c[2].a&&c[2].a==c[3].a&&c[3].a==c[4].a)
||(c[2].a==c[3].a&&c[3].a==c[4].a&&c[4].a==c[5].a))
return true;
else return false;//+else
}
bool _3with2()
{//三带二
if((c[1].a==c[2].a&&c[2].a==c[3].a&&c[4].a==c[5].a)
||(c[1].a==c[2].a&&c[3].a==c[4].a&&c[4].a==c[5].a))
return true;
return false;
}
bool same_col()
{//同花
for(int t=1;t<5;t++)
{
if(c[t].b!=c[t+1].b)
return false;
}
return true;
}
bool sequence()
{//顺子
for(int t=1;t<5;t++)
{
if(c[t+1].a-c[t].a!=1)
return false;
}
return true;
}
bool sc_sequ()
{//同花顺
if(same_col()&&sequence())
return true;
return false;
}
bool three()
{//三条
if((c[1].a==c[2].a&&c[2].a==c[3].a)
||(c[2].a==c[3].a&&c[3].a==c[4].a)
||(c[3].a==c[4].a&&c[4].a==c[5].a))
return true;
return false;
}
bool _2pairs()
{//两对
if((c[1].a==c[2].a&&c[3].a==c[4].a)
||(c[1].a==c[2].a&&c[4].a==c[5].a)
||c[2].a==c[3].a&&c[4].a==c[5].a)
return true;
return false;
}
bool _1pair()
{//一对
if(c[1].a==c[2].a||c[2].a==c[3].a
||c[3].a==c[4].a||c[4].a==c[5].a)
return true;
else return false;
}
void scheme()
{
if(sc_sequ()) ca_type[1]++;
else if(boom()) ca_type[2]++;
else if(_3with2()) ca_type[3]++;
else if(same_col()) ca_type[4]++;
else if(sequence()) ca_type[5]++;
else if(three()) ca_type[6]++;
else if(_2pairs()) ca_type[7]++;
else if(_1pair()) ca_type[8]++;
else ca_type[9]++;
}
int main()
{
cin>>A>>B;
//cin>>c[1].a>>c[1].b>>c[2].a>>c[2].b;
cin>>a1>>b1>>a2>>b2;
c[1].a=a1;
c[1].b=b1;
c[2].a=a2;
c[2].b=b2;
for(int i=0;i<10;i++)
ca_type[i]=0;
int index=1;//tmp数组中的下标
for(int i=0;i<A;i++)
{
for(int j=0;j<B;j++)
{//除去已经确定的两张牌,其余存到tmp数组中
if((i==c[1].a&&j==c[1].b)||(i==c[2].a&&j==c[2].b))
continue;
tmp[index].a=i;
tmp[index].b=j;
index++;
}
}
for(int i=1;i<index;i++)
{
for(int j=1;j<index;j++)
{
for(int k=1;k<index;k++)
{
if(i==j||j==k||i==k)//遍历到同样的牌就继续
continue;
else{
c[1].a=a1;
c[1].b=b1;
c[2].a=a2;
c[2].b=b2;
c[3]=tmp[i];
c[4]=tmp[j];
c[5]=tmp[k];
sort(c+1,c+6);
scheme();
}
}
}
}
for(int i=1;i<=8;i++)
printf("%d ",ca_type[i]/6);
printf("%d",ca_type[9]/6);
return 0;
}