从瑞神家打牌回来后，东东痛定思痛，决定苦练牌技，终成赌神！
东东有 A?×?B 张扑克牌。每张扑克牌有一个大小(整数，记为a，范围区间是 0 到 A?-?1）和一个花色（整数，记为b，范围区间是 0 到 B?-?1。
扑克牌是互异的，也就是独一无二的，也就是说没有两张牌大小和花色都相同。
“一手牌”的意思是你手里有5张不同的牌，这 5 张牌没有谁在前谁在后的顺序之分，它们可以形成一个牌型。 我们定义了 9 种牌型，如下是 9 种牌型的规则，我们用“低序号优先”来匹配牌型，即这“一手牌”从上到下满足的第一个牌型规则就是它的“牌型编号”（一个整数，属于1到9）：
同花顺: 同时满足规则 5 和规则 4.
炸弹 : 5张牌其中有4张牌的大小相等.
三带二 : 5张牌其中有3张牌的大小相等，且另外2张牌的大小也相等.
同花 : 5张牌都是相同花色的.
顺子 : 5张牌的大小形如 x, x?+?1, x?+?2, x?+?3, x?+?4
三条: 5张牌其中有3张牌的大小相等.
两对: 5张牌其中有2张牌的大小相等，且另外3张牌中2张牌的大小相等.
一对: 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 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
每种牌型是固定的，两张起始手牌也是固定的，所以只需要取另外三张牌，然后判断牌型即可。以下有两种解法。
第一种解法，用公式推理是没有问题的，用其他能过OJ的代码生成了几十组数据，进行比对，看上去也没问题，但test2就是过不了
第一种解法用的时间极少，因为判断牌型的算法，是事先推导出公式，赋值计算的。最大的时间消耗便是计算阶乘的步骤了，纯数学题，和程序设计没太大关系。
第二种解法，是常规的解法，三重循环，确定出每一种组合，然后判断牌型，进行统计。
有一点需要注意的是，牌型是互斥的，举例来说，符合“同花顺”的，不再计入“同花”和“顺子”。
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
struct node
{
int A, B;
node(int _A, int _B) :A(_A), B(_B) {
}
node() {
A = 0;
B = 0;
}
};
int A, B;
node p[100];
node n1, n2;
int f(int m, int n) {
if (m < n)return 0;
if (m == n)return 1;
if (n == 0)return 1;
return f(m - 1, n - 1) + f(m - 1, n);
}
int r1() {
if (n1.B != n2.B) {
return 0;
}
else
{
int k1 = max(n1.A, n2.A);
int k2 = min(n1.A, n2.A);
int cnt = 0;
while (k1 < A && k1 - 4 <= k2) {
if(k1-4>=0)
cnt++;
k1++;
}
return cnt;
}
}
int r2() {
if (n1.A == n2.A) {
return f(B - 2, 2) * (A - 1) * B;
}
else {
return 2 * f(B - 1, 3);
}
}
int r3() {
if (n1.A == n2.A) {
return (A - 1) * f(B, 3) + (B-2)*(A-1)*f(B,2);
}
else {
if(B<3){
return 0;
}
else{
return 2*f(B-1,2)*(B-1);
}
}
}
int r4() {
if (n1.B == n2.B) {
return f(A - 2, 3)-r1();
}
else {
return 0;
}
}
int r5() {
if (n1.A == n2.A || abs(n1.A - n2.A) >= 5) {
return 0;
}
else {
int k1 = max(n1.A, n2.A);
int k2 = min(n1.A, n2.A);
int cnt = 0;
while (k1 < A && k1 - 4 <= k2) {
if(k1-4>=0){
cnt++;
}
k1++;
}
if (n1.B == n2.B) {
return cnt-r1();
}
else {
return cnt * (B * B *B)-r1();
}
}
}
int r6() {
if (n1.A == n2.A) {
if(B<3){
return 0;
}
else{
return (B-2)*f(A-1,2)*B*B;
}
}
else {
if (B >= 3){
return 2*f(B-1,2)*(A-2)*B+f(A-2,1)*f(B,3);
}
else
return 0;
}
}
int r7() {
if (n1.A == n2.A) {
return (A-1)*f(B,2)*(A-2)*B;
}
else {
if (B == 1)
return 0;
else
return 2*(B-1)*(A-2)*f(B,2)+(B-1)*(B-1)*(A-2)*B;
}
}
int r8() {
if (n1.A == n2.A) {
return f(A - 1, 3) * B*B*B;
}
else {
if (B == 1)
return 0;
else
return 2 * (B - 1) * f(A - 2, 2) * B * B + (A - 2) * f(B, 2) * (A - 3) * B;
}
}
int main()
{
scanf("%d%d%d%d%d%d", &A, &B, &n1.A, &n1.B, &n2.A, &n2.B);
int n = -1;
for (int i = 0; i < A; ++i) {
for (int j = 0; j < B; ++j) {
p[++n].A = i;
p[n].B = j;
}
}
int sum = f(A * B - 2, 3);
int ans1 = r1();
int ans2 = r2();
int ans3 = r3();
int ans4 = r4();
int ans5 = r5();
int ans6 = r6();
int ans7 = r7();
int ans8 = r8();
int ans9 = sum - (ans1 + ans2 + ans3 + ans4 + ans5 + ans6 + ans7 + ans8);
printf("%d %d %d %d %d %d %d %d %d\n", ans1, ans2, ans3, ans4, ans5, ans6, ans7, ans8, ans9);
return 0;
}
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
struct card
{
int a,b;
card(){}
card(int _a,int _b)
{
a=_a;b=_b;
}
bool operator <(card c)
{
return a<c.a;
}
};
int ans[10];
card c[150];
card s[5];
int main()
{
bool r[10];
int aCnt[25];
int A,B;
int a1,b1,a2,b2;
scanf("%d%d",&A,&B);
scanf("%d%d%d%d",&a1,&b1,&a2,&b2);
int cnt=0;
s[0].a=a1;s[0].b=b1;
s[1].a=a2;s[1].b=b2;
for(int a=0;a<A;a++)
{
for(int b=0;b<B;b++)
{
if((b==b1&&a==a1)||(b==b2&&a==a2))
continue;
c[cnt].a=a;
c[cnt].b=b;
cnt++;
}
}
for(int i=0;i<cnt;i++)
{
if((c[i].a==a1&&c[i].b==b1)||(c[i].a==a2&&c[i].b==b2))
continue;
for(int j=0;j<cnt;j++)
{
if((c[j].a==a1&&c[j].b==b1)||(c[j].a==a2&&c[j].b==b2)||(j==i))
continue;
for(int k=0;k<cnt;k++)
{
if((c[j].a==a1&&c[j].b==b1)||(c[j].a==a2&&c[j].b==b2)||(k==i)||(k==j))
continue;
s[0].a=a1;s[0].b=b1;
s[1].a=a2;s[1].b=b2;
s[2].a=c[i].a; s[2].b=c[i].b;
s[3].a=c[j].a; s[3].b=c[j].b;
s[4].a=c[k].a;s[4].b=c[k].b;
memset(r,0,sizeof(r));
memset(aCnt,0,sizeof(aCnt));
sort(s,s+5);
for(int n=0;n<5;n++)
aCnt[s[n].a]++;
for(int n=0;n<5;n++)
{
if(aCnt[s[n].a]==4)
{
r[2]=true;
break;
}
}
int temp3=0,temp2=0;
for(int n=0;n<5;n++)
{
if(aCnt[s[n].a]==3)
{
temp3++;
}
else if(aCnt[s[n].a]==2)
temp2++;
}
temp3/=2;
temp2/=2;
if(temp3==1&&temp2==1)
r[3]=true;
if(s[0].b==s[1].b&&s[1].b==s[2].b&&s[2].b==s[3].b&&s[3].b==s[4].b)
r[4]=true;
if(s[0].a==(s[1].a-1)&& s[1].a==(s[2].a-1)&& s[2].a==(s[3].a-1)&&s[3].a==(s[4].a-1))
{
r[5]=true;
}
if(temp3==1&&temp2==0)
r[6]=true;
if(temp2==2)
r[7]=true;
if(temp3==0&&temp2==1)
r[8]=true;
if(r[4]==true&&r[5]==true)
ans[1]++;
else if(r[2]==true)
ans[2]++;
else if(r[3]==true)
ans[3]++;
else if(r[4]==true)
ans[4]++;
else if(r[5]==true)
ans[5]++;
else if(r[6]==true)
ans[6]++;
else if(r[7]==true)
ans[7]++;
else if(r[8]==true)
ans[8]++;
else
ans[9]++;
}
}
}
for(int i=1;i<9;i++)
cout<<ans[i]/6<<" ";
cout<<ans[9]/6<<endl;
return 0;
}
程序设计思维与实践 Week6 限时大模拟 (3/4/数据班)
原文：https://www.cnblogs.com/master-cn/p/12639575.html