week6_限时大模拟_掌握魔法的东东（简单枚举）

题目

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