codeforce gym 101726 problem D Poker

D. Poker

time limit per test

2.0 s

memory limit per test

256 MB

input

standard input

output

standard output

Poker is played with a standard 52-card deck (13 ranks and 4 suits). The ranks of the cards, in increasing order, are: 2, 3, ..., 10, Jack, Queen, King and Ace. Given a poker table, with two players, your task is to determine the winner.

Each player has two cards in his hand and there are five common cards to both players. Whichever player has the most valuable 5-card hand, choosing from his own cards and the one on the table, wins. A card on the table may be used by both players at the same time and a player may ignore zero, one or both of his own cards.

To determine the value of a 5-card hand, it is identified as one of the hand types listed below. If the same hand fits more than one type, the most valuable one is chosen. If both players' hands fit the same type, the tie is broken by some rule specific to that type.

The type list, from least to most valuable, and their respective tie-breaking rule are:

• Highest card: If the hand does not fit any of the other types. To break the tie, the five cards are compared, one by one, from highest to lowest rank, until one hand has a higher card then the other;
• One pair: Two cards of the same rank. The tie-breaker is similar the rule in Highest card, first comparing the pair, and then the other three cards;
• Two pairs: Two pairs of different rank. The tie-breaker is first by the most valuable pair, then by the second, then by the last card;
• Three of a kind: Three cards of the same rank. The tie-breaker is analogous to the one in One pair, first compare the triple, then the other two cards;
• Straight: Five cards in a sequence. In this case, the Ace may be either the highest rank (after the King) or the lowest (before the 2). The tie-breaker is done by the card of highest rank, considering that Ace has the lowest rank if it comes before a 2;
• Flush: Five cards of the same suit. The tie-breaker is done like in Highest card;
• Full House: A three of a kind with a pair. The tie-breaker is done by the rank of the three of a kind, and then by the pair;
• Four of a kind: Four cards of the same rank. The tie-breaker is done by the rank of the four of a kind, and then by the last card;
• Straight Flush: Straight and Flush at the same time. The tie-breaker is the same as in Straight.

  Notice that it is possible for the tie to persist even after the tie-breaker rules are applied. The suits of a card are only used to define a Flush, and are not used in any tie-breaker rule.

Input

On the first line, an integer T, the number of test cases.

Each test case is given in three lines. The first two lines have the description of two cards each, the cards of the first player, and of the second. The last line has the description of five cards, the cards on the table.

The description of each card is given by two characters, the rank and the suit, as given in the table.

Limits

• 1 ≤ T ≤ 105
• For each test case, all cards are valid and distinct.

Output

For each test, print 1 if the first player wins, 2 if the second player wins, and 0 if there is a tie, even after applying the tie-breaker rules.

Example

input

Copy

3
Ts Js
Tc Jc
Qs Qc Ks Kc As
As 7d
Ah 8s
Ac Ad 9s Jh Kc
As 7d
Ah 8s
Ac Ad 6s 3h Kc

output

Copy

1
0
2
思路：按规则模拟即可。判断当前是什么类型优先判断是否满足等级高的类别。

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> T;
*/

int t;
struct gg {
    int v, co;
    gg () {}
    gg (int v, int co) : v(v), co(co) {}
    void input() {
        char c = getchar();
        while (!isalpha(c) && !isdigit(c)) c = getchar();
        if ('T' == c) {
            v = 10;
        } else if ('J' == c) {
            v = 11;
        } else if ('Q' == c) {
            v = 12;
        } else if ('K' == c) {
            v = 13;
        } else if ('A' == c) {
            v = 14;
        } else {
            v = c - '0';
        }
        co = getchar();
    }
    bool operator < (const gg &g) const {
        return v < g.v;
    }
} g1[10], g2[10];
struct hh {
    int type;
    gg g[5];
    void modify() {
        sort(g, g + 5);
    }
    void output() {
        printf("type = %d ", type);
        for (int i = 0; i < 5; ++i) {
            printf("%d %c ", g[i].v, g[i].co);
        }
        puts("");
    }
    int is_flush() const {
        for (int i = 1; i < 5; ++i) {
            if (g[i].co != g[0].co) return 0;
        }
        return g[4].v;
    }
    int is_straight() const {
        int f = 1;
        for (int i = 3; ~i; --i) {
            if (g[i].v != g[i + 1].v - 1) {
                f = 0;
                break;
            }
        }
        if (f) return g[4].v;
        f = 1;
        if (14 == g[4].v) {
            for (int i = 0; i < 4; ++i) {
                if (g[i].v != i + 2) {
                    f = 0;
                    break;
                }
            }
        } else {
            f = 0;
        }
        return f ? 5 : 0;
    }
    int is_pair() const {
        int i;
        for (i = 4; i; --i) {
            if (g[i].v == g[i - 1].v && (1 == i || g[i].v != g[i - 2].v) && (4 == i || g[i].v != g[i + 1].v)) {
                break;
            }
        }
        if (i) {
            int res = g[i].v;
            for (int j = 4; ~j; --j) {
                if (i == j || i - 1 == j) continue;
                res = res * 20 + g[j].v;
            }
            return res;
        }
        return 0;
    }
    int is_triple() const {
        if (g[4].v == g[2].v) return g[4].v * 400 + g[1].v * 20 + g[0].v;
        if (g[3].v == g[1].v) return g[3].v * 400 + g[4].v * 20 + g[0].v;
        if (g[2].v == g[0].v) return g[2].v * 400 + g[4].v * 20 + g[3].v;
        return 0;
    }
    int is_fouple() const {
        if (g[4].v == g[1].v) return g[4].v * 20 + g[0].v;
        if (g[3].v == g[0].v) return g[3].v * 20 + g[4].v;
        return 0;
    }
    int is_two_pair() const {
        if (g[4].v == g[3].v && g[2].v == g[1].v) return g[4].v * 400 + g[2].v * 20 + g[0].v;
        if (g[4].v == g[3].v && g[1].v == g[0].v) return g[4].v * 400 + g[1].v * 20 + g[2].v;
        if (g[3].v == g[2].v && g[1].v == g[0].v) return g[3].v * 400 + g[1].v * 20 + g[4].v;
        return 0;
    }
    pii is_house() const {
        if (g[4].v == g[2].v && g[1].v == g[0].v) return pii(g[4].v, g[1].v);
        if (g[4].v == g[3].v && g[2].v == g[0].v) return pii(g[2].v, g[4].v);
        return pii(0, 0);
    }
    int get_type() const {
        int ff = is_flush();
        int fs = is_straight();
        int fp = is_pair();
        int ft = is_triple();
        if (fs) {
            return ff ? 9 : 5;
        } else if (is_fouple()) {
            return 8;
        } else if (fp && ft) {
            return 7;
        } else if (ff) {
            return 6;
        } else if (ft) {
            return 4;
        } else if (is_two_pair()) {
            return 3;
        } else if (is_pair()) {
            return 2;
        } else {
            return 1;
        }
    }
    bool operator < (const hh h) const {
        if (type != h.type) return type < h.type;
        if (1 == type) {
            for (int i = 4; ~i; --i) {
                if (g[i].v != h.g[i].v) return g[i].v < h.g[i].v;
            }
            return false;
        } else if (2 == type) {
            return is_pair() < h.is_pair();
        } else if (3 == type) {
            return is_two_pair() < h.is_two_pair();
        } else if (4 == type) {
            return is_triple() < h.is_triple();
        } else if (5 == type) {
            return is_straight() < h.is_straight();
        } else if (6 == type) {
            for (int i = 4; ~i; --i) {
                if (g[i].v != h.g[i].v) return g[i].v < h.g[i].v;
            }
            return false;
        } else if (7 == type) {
            return is_house() < h.is_house();
        } else if (8 == type) {
            return is_fouple() < h.is_fouple();
        } else {
            return is_straight() < h.is_straight();
        }
    }
} h1, h2, th;
int main() {
    scanf("%d", &t);
    while (t--) {
        g1[1].input(), g1[2].input();
        g2[1].input(), g2[2].input();
        for (int i = 1; i <= 5; ++i) {
            g1[i + 2].input();
            g2[i + 2] = g1[i + 2];
        }
        h1.type = h2.type = 0;
        for (int i = 1; i <= 7; ++i) {
            for (int j = i + 1; j <= 7; ++j) {
                for (int k = 1, l = 0; k <= 7; ++k) {
                    if (k == i || k == j) continue;
                    th.g[l++] = g1[k];
                }
                th.modify();
                th.type = th.get_type();
                if (h1 < th) {
                    h1.type = th.type;
                    for (int i = 0; i < 5; ++i) {
                        h1.g[i] = th.g[i];
                    }
                }
            }
        }
        for (int i = 1; i <= 7; ++i) {
            for (int j = i + 1; j <= 7; ++j) {
                for (int k = 1, l = 0; k <= 7; ++k) {
                    if (k == i || k == j) continue;
                    th.g[l++] = g2[k];
                }
                th.modify();
                th.type = th.get_type();
                if (h2 < th) {
                    h2.type = th.type;
                    for (int i = 0; i < 5; ++i) {
                        h2.g[i] = th.g[i];
                    }
                }
            }
        }
        //h1.output(), h2.output();
        if (h1 < h2) puts("2");
        else if (h2 < h1) puts("1");
        else puts("0");
    }
    return 0;
}
/*
111
9h 8h
Jc 9d
9s 4d Ts Ad As
*/