rhino.cpp

#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
 
#define DEBUG(x) cout << ">>> " << #x << " : " << x << endl;
#define REP(i,a) for (int i = 0; i < (a); ++i)
#define FOR(i,a,b) for (int i = (a); i <= (b); ++i)
#define FORD(i,a,b) for (int i = (a); i >= (b); --i)
inline bool EQ(double a, double b) { return fabs(a-b) < 1e-9; }
 
const int INF = 1<<29;
typedef long long ll;
///////////////////////////////////////////////////////////////////////////
 
const int MAX = 14;
 
int get_rank(char c)
{
  switch(c)
  {
    case '2': return 1; break;
    case '3': return 2; break;
    case '4': return 3; break;
    case '5': return 4; break;
    case '6': return 5; break;
    case '7': return 6; break;
    case '8': return 7; break;
    case '9': return 8; break;
    case 'X': return 9; break;
    case 'J': return 10; break;
    case 'Q': return 11; break;
    case 'K': return 12; break;
    case 'A': return 13; break;
  }
  DEBUG("AAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
  return -1;
}
 
int get_suit(char c)
{
  switch(c)
  {
    case 'c': return 0; break;
    case 'd': return 1; break;
    case 'h': return 2; break;
    case 's': return 3; break;
  }
  DEBUG("AAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
  return -1;
}
 
struct Card
{
  int rank, suit;
};
 
struct Hand
{
  int type;
  int order;
  Hand(): type(-1), order(0) {}
 
  bool operator<(const Hand & h) const
  {
    return type < h.type || (type == h.type && order < h.order);
  }
 
  bool operator==(const Hand & h) const
  {
    return type == h.type && order == h.order;
  }
};
 
int get_order(int start, vector<int> & v)
{
  REP(i, v.size())
    start = start*MAX + v[v.size()-1-i];
}
 
int ranks[MAX], suits[4];
Hand get_hand(vector<Card> & cards)
{
  memset(ranks, 0, sizeof(ranks));
  memset(suits, 0, sizeof(suits));
  REP(i, cards.size())
  {
    ++ranks[cards[i].rank];
    ++suits[cards[i].suit];
  }
 
  int straight = 0, flush = 0;
  vector<int> one, two, three, four;
  REP(i, MAX)
    if (ranks[i] == 1) one.push_back(i);
    else if (ranks[i] == 2) two.push_back(i);
    else if (ranks[i] == 3) three.push_back(i);
    else if (ranks[i] == 4) four.push_back(i);
  REP(i, 4)
    if (suits[i] == 5) ++flush;
 
  ranks[0] = ranks[MAX-1];
  REP(i, MAX)
  {
    if (i+5 > MAX) break;
    bool ok = true;
    REP(j, 5)
      if (!ranks[i+j]) ok = false;
    if (ok) straight = i+1;
  }
 
  Hand result;
  // royal flush
  if (straight && flush)
  {
    result.type = 8;
    result.order = straight;
  }
  // poker
  else if (four.size())
  {
    result.type = 7;
    result.order = four[0] * MAX + one[0];
  }
  // full house
  else if (three.size() && two.size())
  {
    result.type = 6;
    result.order = three[0] * MAX + two[0];
  }
  // flush
  else if (flush)
  {
    result.type = 5;
    result.order = get_order(0, one);
  }
  // straight
  else if (straight)
  {
    result.type = 4;
    result.order = straight;
  }
  // three
  else if (three.size())
  {
    result.type = 3;
    result.order = three[0];
    result.order = get_order(result.order, one);
  }
  // two pairs
  else if (two.size() == 2)
  {
    result.type = 2;
    result.order = get_order(0, two);
    result.order = get_order(result.order, one);
  }
  // pair
  else if (two.size())
  {
    result.type = 1;
    result.order = two[0];
    result.order = get_order(result.order, one);
  }
  // one card
  else
  {
    result.type = 0;
    result.order = get_order(0, one);
  }
 
  return result;
}
 
Card table[7], player[10][2];
 
int main()
{
  int N;
  while (scanf("%d", &N) == 1)
  {
    char r, s;
    REP(i, 5)
    {
      scanf(" %c %c", &r, &s);
      table[i].rank = get_rank(r);
      table[i].suit = get_suit(s);
    }
    REP(i, N) REP(j, 2)
    {
      scanf(" %c %c", &r, &s);
      player[i][j].rank = get_rank(r);
      player[i][j].suit = get_suit(s);
    }
 
    Hand best;
    vector<int> winners;
    REP(p, N)
    {
      table[5] = player[p][0];
      table[6] = player[p][1];
      Hand hand;
      FOR(f1, 0, 6) FOR(f2, f1+1, 6)
      {
	vector<Card> h;
	REP(i, 7)
	  if (i != f1 && i != f2)
	    h.push_back(table[i]);
	Hand temp = get_hand(h);
	if (hand < temp) hand = temp;
      }
 
      if (best < hand)
      {
	best = hand;
	winners.clear();
      }
      if (best == hand)
      {
	winners.push_back(p);
      }
    }
 
    REP(i, winners.size())
    {
      if (i) printf(" ");
      printf("%d", winners[i]+1);
    }
    printf("\n");
  }
  return 0;
}