Uva 131 - The Psychic Poker Player

 The Psychic Poker Player

题目链接：

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=67

题目输入的每一行就是一个Case，前面五个表示你现在手上的牌，后面五个是放在桌上的牌，这五张牌叠在一起，牌面的值向下铺着，所以你看不到值，题目要你做的就是：你可以将你手中不要的牌拿走，可以是1张，2张...5张，当然你也可以不拿走。你从你手中的牌拿走多少张然后就从桌上的那些牌上从上到下取的方式拿走多少张，在这个的过程中，你要判断出你手中最好的牌的情况是什么，最终要把这种情况输出，这些情况在Sample中已经将所有的可能表示出来了，而且是有优先顺序的（即从上到下，上面的符合了下面的就不用判断了） 这些情况翻译成中文来就是：

//0 straight-flush　　 同花顺 == 一手同花的五张牌 + 五张牌点数连续的顺子
//1 four-of-a-kind 　  四张相同 的牌
//2 full-house 　　     满堂红 三张同点牌加上一对
//3 flush 　　　　　　 一手同花的五张牌
//4 straight 　　　　  五张牌点数连续的顺子
//5 three-of-a-kind    三张相同的牌
//6 two-pairs 　　　　两对对子
//7 one-pair 　　       一对对子
//8 highest-card       这个我也不知道，上面的所有情况不符合，那么就只有输出它了

为了找到最好的那种情况，你就必须从桌上分别拿：0， 1， 2， 3 ，4， 5张牌然后判断情况， 而拿了桌上的牌后（如果不为零）你就必须舍掉你手上现有的牌来替换它，然后来判断情况，比如说：你从桌上那1张牌，那么替换你手中的牌就有5种情况；你从桌上拿2张牌，你就要替换你手中的任意两张牌（C5取2中可能），等等

我的做法是：

Uva的上面的一题让我学到了位运算（如果不懂位运算，先看看我上一篇随笔），先不看桌上的牌，先想想替换你手中的牌的情况共有多少种？核心是这段代码：

for(int i=0; i<(1<<5); ++i)
{
　　int num = 0;
　　for(int j=0; j<5; ++j)  
　　if(i&(1<<j)) num++;    

}

先看 1<<j求出来的究竟是什么，从 0到4， 1<<j 的值为： 1， 10， 100， 1000， 10000 （每次都是这样）

而 i 的值呢？ 从 0 到 1111，这时的 i 与 上五个不同值的(1<<j)，得到的num表示 i 中有多少个 1， 如果 (i&(1<<j)) == true 的话，那么这时就说明 有 1 在 j 这个位置

i 所在的for结束后，那么纸牌的全部替换的情况都遍历了，尽管第一次可能替换你1张牌，第二次却替换你2张牌，第三次却又替换了你的1张牌，但位置时不同的，思考一下就会知道所有的情况在用上位运算后就很完美的处理掉了！

然后你要做的：

处理现在在你手中的牌，给牌排序，关键字有两个，牌值得大小和牌的花色，基数排序没必要，我就用了以前的方式，排完牌值大小的基础上再处理花色的问题。但在排牌之前最好先处理一下用字符代表牌的方式，转换成数字，比如说A=1, T=10,  k=13; C = 1,  S = ... 用类型为整型的二维数组存储一下，这样相对比较简单

牌的顺序排好后，这时就要看判断符合上面给的情况的那种了：

这就意味着要写8个判断的函数了（最后一种情况不要了，默认为最后一种情况），每个函数根据返回的值是1或0来判断

这样处理下去大概就差不多了， 需要注意的是：判断是否为顺子的时候，A可以放在第一位，也可以放在最后（即K的后面）

PS：

这次出的题目考虑得全面，并没有让做题者有疑惑或难堪的地方

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
char poke[12][4], temp[12][4];
int transfer[6][2];
char output[10][20];
int res;

void memset_1(char (*des)[4], char (*src)[4])
{
    for(int i=0; i<10; i++)
    strcpy(des[i], src[i]);
    return;
}

int  prior(char elem)
{
    if('2'<= elem && elem <= '9') return (elem - '0');
    switch(elem)
    {
        case 'A' : return 1;
        case 'T' : return 10;
        case 'J' : return 11;
        case 'Q' : return 12;
        case 'K' : return 13;
        
        case 'C' : return 1;
        case 'D' : return 2;
        case 'H' : return 3;
        case 'S' : return 4;
    }
    return -1;
}

void swap_1(int left, int right)
{
    int sw[2];
    sw[0] = transfer[left][0];
    sw[1] = transfer[left][1];
    transfer[left][0] = transfer[right][0];
    transfer[left][1] = transfer[right][1];
    transfer[right][0] = sw[0];
    transfer[right][1] = sw[1];
    return;
}

void basesort()
{
    for(int i=0; i<5; ++i)
    {
        for(int j=0; j<=1; ++j)
        transfer[i][j] = prior(temp[i][j]);
    }
    for(int i=0; i<4; ++i)
    {
        int flag = 0;
        for(int j=0; j<4-i; ++j)
        if(transfer[j][0] > transfer[j+1][0])
        {
            swap_1(j, j+1);
            flag = 1;
        }
        if(!flag) break;
    }
    for(int part1=0, part2=0, i=0; i<5; i++)
    {
        if(i+1<5 && transfer[i][0] == transfer[i+1][0])
            part2++;
        else
        {
            for(int t=0; t<part2-part1; ++t)
            {
                int flag = 0;
                for(int j=part1; j<part2-t; ++j)
                if(transfer[j][1] > transfer[j+1][1])
                {
                    swap_1(j, j+1);
                    flag = 1;
                }
                if(!flag) break;
            }
            part1 = part2 = i+1;
        }
    }
    return;
}

void Print()
{
    for(int i=0; i<5; ++i)
    cout<<temp[i]<<" ";
    return;
}

int is_straight_flush()
{
    int flag = 1;
    for(int i=1; i<5; ++i)
    {
        if(transfer[i-1][0]+1 != transfer[i][0] || transfer[i-1][1] != transfer[i][1])
        {
            flag = 0;
            break;
        }
    }
    if(flag) return 1;
    else 
    {
        if(transfer[0][0] == 1 && transfer[1][0] == 10 && transfer[0][1] == transfer[1][1])
        {
            flag = 1;
            for(int i=2; i<5; ++i)
            if(transfer[i-1][0]+1 != transfer[i][0] || transfer[i-1][1] != transfer[i][1])
            {
                flag = 0;
                break;
            }
        }
        return flag;
    }
}

int is_four()
{
    for(int i=0; i<=1; ++i)
    {
        int flag = 1;
        for(int j=i+1; j<4+i; ++j)
        {
            if(transfer[j][0] != transfer[j-1][0])
            {
                flag = 0;
                break;
            }
        }
        if(flag) return 1;
    }
    return 0;
    
}

int is_full()
{
    if(transfer[0][0] == transfer[1][0] && transfer[3][0] == transfer[4][0])
    {
        if(transfer[1][0] == transfer[2][0] || transfer[2][0] == transfer[3][0])
        return 1;    
    }
    return 0;
}

int is_flush()
{
    for(int i=1; i<5; ++i)
    if(transfer[i-1][1] != transfer[i][1])
        return 0;
    return 1;
}

int is_straight()
{
    int flag = 1;
    for(int i=1; i<5; ++i)
    if(transfer[i-1][0]+1 != transfer[i][0])
    {
        flag = 0;
        break;
    } 
    if(flag) return 1;
    else
    {
        if(transfer[0][0] == 1 && transfer[1][0] == 10)
        {
            flag = 1;
            for(int i=2; i<5; ++i)
            if(transfer[i-1][0] != transfer[i][0])
            {
                flag = 0;
                break;
            }
        }
        return flag;
    }
}

int is_three()
{
    for(int i=0; i<=2; ++i)
    {
        if(transfer[i][0] == transfer[i+1][0] && transfer[i+1][0] == transfer[i+2][0]) 
        return 1;
    }
    return 0;
}

int is_two()
{
    if(transfer[0][0] == transfer[1][0])
    {
        if(transfer[2][0] == transfer[3][0] || transfer[3][0] == transfer[4][0])
        return 1;
    }
    if(transfer[1][0] == transfer[2][0] && transfer[3][0] == transfer[4][0])
        return 1;
    return 0;
}

int is_one()
{
    for(int i=0; i<=3; ++i)
    {
        if(transfer[i][0] == transfer[i+1][0]) return 1;
    }
    return 0;
}

void Traverse()
{
    basesort();
    
    if(is_straight_flush())    {res = 0; return;}
    if(is_four())              {res = 1; return;}
    if(is_full())              {res = res < 2 ? res : 2; return;}
    if(is_flush())             {res = res < 3 ? res : 3; return;}
    if(is_straight())          {res = res < 4 ? res : 4; return;}
    if(is_three())             {res = res < 5 ? res : 5; return;}
    if(is_two())               {res = res < 6 ? res : 6; return;}
    if(is_one())               {res = res < 7 ? res : 7; return;}
}

void memset_2()
{
    strcpy(output[0], "straight-flush");
    strcpy(output[1], "four-of-a-kind");
    strcpy(output[2], "full-house");
    strcpy(output[3], "flush");
    strcpy(output[4], "straight");
    strcpy(output[5], "three-of-a-kind");
    strcpy(output[6], "two-pairs");
    strcpy(output[7], "one-pair");
    strcpy(output[8], "highest-card");
}

int main()
{
/*  freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
*/
    int sequence[6];
    for(int r=0; r<6; r++) sequence[r] = r+1;
    memset_2();
    while(cin>>poke[0])
    {
        for(int i=2; i<=10; ++i)
            cin>>poke[i-1];
        res = 8;
        for(int i=0; i<(1<<5); ++i)
        {
            int num = 0;
            memset_1(temp, poke);
            for(int j=0; j<5; ++j)
            if(i&(1<<j)) num++;
            sort(sequence, sequence+6);
            int cnt=0;
            for(int j=0; j<5; ++j)
            if(i&(1<<j)) strcpy(temp[j], temp[(sequence[cnt++]+4)]);
            Traverse();
            if(res == 0) break;
        }
        cout<<"Hand: ";
        for(int i=0; i<5; ++i)
        cout<<poke[i]<<" ";
        cout<<"Deck: ";
        for(int i=5; i<10; ++i)
        cout<<poke[i]<<" ";
        cout<<"Best hand: "; 
        cout<<output[res]<<endl;
    }
    return 0;
}