UVA Poker Hands题解

我是使用分支选择的方式求解的结果，谢了接近350行的代码，中途的调试时间也非常的长。确实，代码冗长的时候，错误就会不可避免的发生。

看了看网上某大神的大作，感觉到差距巨大，甚是惭愧，在此放上大神的代码，督促自己。

转子博客：http://blog.csdn.net/mobius_strip/article/details/47047513

题目：两个人手里各有五张牌，比较两牌型大小。

            比较规则如下：（按优先级排序，优先级相同按下面内部规则比较）

            1.straight-flush：同花顺，牌面连续，花色相同，按最大的值比较；

            2.four-of-a-kind：四条，牌面有四个相同的值，按四个的牌面比较；

            3.full-house：船牌，牌面有三个相同值，剩下两个也相同值，按三个的牌面比较；

            4.flush：同花，五张牌的花色相同，不是顺子，按牌面最大的开始比，相同比较下一个；

            5.straight：顺子，五张牌的值连续，按最大的值比较；

            6.three-of-a-kind：三条，牌面有三个相同的值，按三个的牌面比较；

            7.two-pairs：两对，牌面有两个对子，比较最大的对子，相同比较第二对，相同比较剩下的；

            8.one-pair：一对，牌面有一个对子，即两个同值，比对子，相同则按同花比较；

            9.highest-card：大牌，没有以上牌型，和同花比较方式相同。

分析：模拟。可以使用条件分支不断判断，不过判断嵌套太多，代码较长。

            这里使用一种映射方法，将9种牌型映射到9个互补重叠的单调区间比较；

            1.straight-flush：同花顺，区间[13^5+40，13^5+53]；

            2.four-of-a-kind：四条，区间[13^5+20，13^5+33]；

            3.full-house：船牌，区间[13^5+1，13^5+14]；

            4.flush：同花，区间[13^4，13^5]；

            5.straight：顺子，区间[-20，-5]；

            6.three-of-a-kind：三条，区间[-40，-25]；

            7.two-pairs：两对，区间[-8000，-2000]；

            8.one-pair：一对，区间[-13^5*2，-13^4]；

            9.highest-card：大牌，区间[-13^5*4，13^5*3]；

            具体操作参照代码（把数据看成是13进制比较好理解）。

说明：UVa131类似物，╮(╯▽╰)╭。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;

int value( char ch )
{
    if ( ch == 'T' ) return 8;
    if ( ch == 'J' ) return 9;
    if ( ch == 'Q' ) return 10;
    if ( ch == 'K' ) return 11;
    if ( ch == 'A' ) return 12;
    return ch - '2';
}

int color( char ch )
{
    if ( ch == 'S' ) return 0;
    if ( ch == 'H' ) return 1;
    if ( ch == 'D' ) return 2;
    if ( ch == 'C' ) return 3;
}

int tests(char cards[][3])
{
    //冒泡终于有用武之地了╮(╯▽╰)╭
    for (int i = 5; i > 1; -- i)
        for (int j = 1; j < i; ++ j)
            if (cards[j-1][0] > cards[j][0]) {
                swap(cards[j-1][0], cards[j][0]);
                swap(cards[j-1][1], cards[j][1]);
            }
    
    int maps[5][13];
    memset(maps, 0, sizeof(maps));  
    for (int i = 0; i < 5; ++ i) {  
        maps[color(cards[i][1])][value(cards[i][0])] ++;  
        maps[4][value(cards[i][0])] ++;  
    }
    //royal-flush | straight-flush
    for (int i = 0; i < 4; ++ i)
        for (int j = 0; j < 9; ++ j)
            if (maps[i][j]&maps[i][j+1]&maps[i][j+2]&maps[i][j+3]&maps[i][j+4])
                return 13*13*13*13*13+40+j;
    //four-of-a-kind
    for (int i = 0; i < 13; ++ i)
        if (maps[4][i] >= 4) return 13*13*13*13*13+20+i;
    //full-house
    int three = 0,two = 0;
    for (int i = 12; i >= 0; -- i) {
        if (maps[4][i] == 2)
            two = two*15+i+1;
        if (maps[4][i] == 3)
            three = i+1;
    }
    if (two && three) return 13*13*13*13*13+three+1;
    //flush
    for (int i = 0; i < 4; ++ i) {
        int count = 0, number = 0;
        for (int j = 12; j >= 0; -- j)
            for (int k = 0; k < maps[i][j]; ++ k) {
                ++ count;
                number = number*13+j;
            }
        if (count == 5) return number;
    }
    //straight
    for (int i = 0; i < 9; ++ i)
        if (maps[4][i]&maps[4][i+1]&maps[4][i+2]&maps[4][i+3]&maps[4][i+4])
            return i-20;
    //three-of-a-kind
    if (three) return three-40;
    
    int ans = 0;
    for (int i = 12; i >= 0; -- i)
        if (maps[4][i] == 1)
            ans = ans*13+i;
    //two-pairs
    if (two >= 15) two*15+ans-8000;
    //one-pair
    if (two) return two*13*13*13+ans-13*13*13*13*30;
    //high-card
    return ans-13*13*13*13*50;
}

int main()
{
    char white[5][3],black[5][3];
    while ( ~scanf("%s",black[0]) ) {
        for (int i = 1; i < 5; ++ i)
            scanf("%s",black[i]);
        for (int i = 0; i < 5; ++ i)
            scanf("%s",white[i]);
            
        int value = tests(black)-tests(white);
        if (value < 0)
            printf("White wins.\n");
        else if (value > 0)
            printf("Black wins.\n");
        else printf("Tie.\n");
    }
    return 0;
}