UVaOJ 131 – The Psychic Poker Player

——by A Code Rabbit

Description

一道蛋疼的题目，堪称模拟题。

玩牌。

你有5张手牌，可以舍弃任意张，然后从桌上抽牌。

这时候，你突然牛逼了，你可以洞察桌上从上到下放的都是什么牌。

好了。

输入你手上的5张牌和桌面最上方的5张牌。

输出你可以拿到的最强的组合。

Types

Brute Force :: Elementary Skills

Analysis

要想A题，还要会玩扑克。

题目的样例已经给出扑克的各种组合的名称，并且从上到下，从强到弱。

这里也大概蛋疼得说明一下——

straight-flush，5张牌花色相同，点数递增1。
four-of-a-kind，5张牌有4张牌点数相同。
full-house，5张牌有3张牌点数相同，而且另外2张点数也相同。
flush，5张牌花色相同，但是点数没有递增1。
straight，5张牌点数递增1，但是花色不同。
three-of-a-kind，5张牌有3张点数相同，另外2张点数不同。
two-pairs，5张牌有两对牌点数相同。
one-pair，5张牌有一对牌点数相同。
highest-card，木有符合上面任何条件。

好了，接下来就是枚举弃牌的各种情况，然后各种蛋疼的判断函数，去判断牌属于什么类型。

枚举的时候，可以利用二进制数位运算。例如，

01010

就表示保留第二张和第四张牌，然后从桌上抽3张牌补齐5张。

而判断的时候，可以利用计数的思想——

用一个count数组，计算点数出现的次数。
再用另一个count数组，计算“点数出现次数”出现的次数……（虽然很绕口，但是你懂的）
这样就方便多了。

Solution

// UVaOJ 131
// The Psychic Poker Player
// by A Code Rabbit

#include <cstdio>
#include <cstring>
#include <map>

using namespace std;

struct Poker {
char value;
char suit;
};

const int NUM_CARD = 5;
const int LIMITS_VALUES = 15;

const char str_write[][20] = {
"highest-card",
"one-pair",
"two-pairs",
"three-of-a-kind",
"straight",
"flush",
"full-house",
"four-of-a-kind",
"straight-flush",
};

enum Type {
HIGHEST_CARD,
ONE_PAIR,
TWO_PAIRS,
THREE_OF_A_KIND,
STRAIGHT,
FLUSH,
FULL_HOUSE,
FOUR_OF_A_KIND,
STRAIGHT_FLUSH,
};

char ch;

map<char, int> int_value;

Poker hand[NUM_CARD];
Poker deck[NUM_CARD];
Type type_max;

int count_value[LIMITS_VALUES];
int count_value_same[NUM_CARD];

bool IsSameSuit(Poker card[]);
bool IsOrder(Poker card[]);
Type JudgeType(Poker card[]);

void Search(int x);

int main() {
// Make map.
int_value['A'] = 1;
for (int i = 2; i < 10; ++i) {
int_value['0' + i] = i;
}
int_value['T'] = 10;
int_value['J'] = 11;
int_value['Q'] = 12;
int_value['K'] = 13;

// Let's start the game!
while (scanf("%c%c%c", &hand[0].value, &hand[0].suit, &ch) != EOF) {
// Inputs.
for (int i = 1; i < NUM_CARD; ++i) {
scanf("%c%c%c", &hand[i].value, &hand[i].suit, &ch);
}
for (int i = 0; i < NUM_CARD; ++i) {
scanf("%c%c%c", &deck[i].value, &deck[i].suit, &ch);
}
// Search.
type_max = HIGHEST_CARD;
for (int i = 0; i < 1 << NUM_CARD; ++i) {
Search(i);
}
// Outputs.
printf("Hand: ");
for (int i = 0; i < NUM_CARD; ++i) {
printf("%c%c ", hand[i].value, hand[i].suit);
}
printf("Deck: ");
for (int i = 0; i < NUM_CARD; ++i) {
printf("%c%c ", deck[i].value, deck[i].suit);
}
printf("Best hand: %s\n", str_write[type_max]);
}
return 0;
}

bool IsSameSuit(Poker card[]) {
for (int i = 1; i < NUM_CARD; ++i) {
if (card[i].suit != card[0].suit) {
return false;
}
}
return true;
}

bool IsOrder(Poker card[]) {
memset(count_value, 0, sizeof(count_value));
for (int i = 0; i < NUM_CARD; ++i) {
++count_value[int_value[card[i].value]];
if (card[i].value == 'A') {
++count_value[14];
}
}
int num = 0;
for (int i = 0; i < LIMITS_VALUES && num < 5; ++i) {
if (count_value[i]) {
++num;
} else {
num = 0;
}
}
if (num == 5) {
return true;
} else {
return false;
}
}

Type JudgeType(Poker card[]) {
memset(count_value, 0, sizeof(count_value));
memset(count_value_same, 0, sizeof(count_value_same));
for (int i = 0; i < NUM_CARD; ++i) {
++count_value[int_value[card[i].value]];
}
for (int i = 1; i <= 13; ++i) {
++count_value_same[count_value[i]];
}

if (IsSameSuit(card) && IsOrder(card)) {
return STRAIGHT_FLUSH;
} else
if (count_value_same[4]) {
return FOUR_OF_A_KIND;
} else
if (count_value_same[3] && count_value_same[2]) {
return FULL_HOUSE;
} else
if (IsSameSuit(card)) {
return FLUSH;
} else
if (IsOrder(card)) {
return STRAIGHT;
} else
if (count_value_same[3]) {
return THREE_OF_A_KIND;
} else
if (count_value_same[2] == 2) {
return TWO_PAIRS;
} else
if (count_value_same[2] == 1) {
return ONE_PAIR;
} else {
return HIGHEST_CARD;
}
}

void Search(int x) {
Poker card[NUM_CARD];
int top = 0;
for (int i = 0; i < NUM_CARD; ++i) {
if (x & (1 << i)) {
card[top++] = hand[i];
}
}
for (int i = 0; i < NUM_CARD && top < 5; ++i) {
card[top++] = deck[i];
}
Type type = JudgeType(card);
type_max = type > type_max ? type : type_max;
}

下载PDF

参考资料：刺客的博客