r.cpp

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <utility>
#include <stack>
#include <vector>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <list>
 
#define SIZEOF(a) (sizeof(a)/sizeof(a[0]))
#define FILL(a,b) fill(a,a+SIZEOF(a),b)
#define FOR(a,b,c) for(int a=b;a<=c;a++)
#define FORARR(i,a) for(unsigned i=0; i<SIZEOF(a); i++)
#define FOREACH(a,b) for(__typeof((b).begin()) a = (b).begin(); a!=(b).end(); a++)
#define GETI(a) scanf("%d ", &a);
#define SWAP(a,b) { __typeof(a) t = a; a = t; b = t; }
 
#define CV(i) cards[i].value
 
using namespace std;
 
struct card {
  int value;
  char color;
  card() {}
  card(char val, char color) : color(color) {
    switch (val) {
      case 'X':
	value = 10;
	break;
      case 'J':
	value = 11;
	break;
      case 'Q':
	value = 12;
	break;
      case 'K':
	value = 13;
	break;
      case 'A':
	value = 14;
	break;
      default:
	value = val - '0';
    }
  }
};
 
bool operator<(const card& c, const card& d) {
  return c.value < d.value;
}
 
int highest_value(const card* cards, int num) {
  int h = 0;
  FOR(i,0,num-1) {
    h = max(h, cards[i].value);
  }
  return h;
}
 
bool same_color(const card* cards, int num) {
  char col = cards[0].color;
  FOR(i,1,num-1) {
    if (cards[i].color != col) {
      return false;
    }
  }
  return true;
}
 
struct player {
  card cards[2];
};
 
 
bool is_straight(const card* cards)
{
  if (cards[0].value == 1 && cards[1].value == 2 && cards[2].value == 3 && cards[3].value == 4 && cards[4].value == 14) {
    return true;
  }
 
  int fval = CV(0);
  FOR(i,1,4) {
    if (fval + i != cards[i].value) {
      return false;
    }
  }
  return true;
}
 
 
// cards: 5 cards sorted by value
int get_score(const card* cards)
{
  // royal flush
  if (same_color(cards, 5) && is_straight(cards)) {
    return 10000000 + cards[3].value;
  }
 
  // poker
  int mid = cards[2].value;
  bool pokerBroken = false;
  FOR(i,0,3) {
    if (cards[i].value != mid) {
      pokerBroken = true;
      break;
    }
  }
  if (!pokerBroken) {
    return 9000000 + mid;
  }
  // for i, 1, 4
  pokerBroken = false;
  FOR(i,1,4) {
    if (cards[i].value != mid) {
      pokerBroken = true;
      break;
    }
  }
  if (!pokerBroken) {
    return 9000000 + mid;
  }
 
  // full house
  if (cards[0].value == cards[1].value && cards[3].value == cards[4].value) {
    if (cards[2].value == cards[0].value || cards[2].value == cards[4].value) {
      return 8000000 + 15*cards[2].value;
    }
  }
 
  // flush
  if (same_color(cards, 5)) {
    return 7000000 + 15*15*15*15*cards[4].value + 15*15*15*cards[3].value + 15*15*cards[2].value + 15*cards[1].value + cards[0].value;
  }
 
  // straight
  if (is_straight(cards)) {
    return 6000000 + cards[3].value;
  }
 
  // three
  if (cards[0].value == mid && cards[1].value == mid) {
    return 5000000 + mid * 15*15 + cards[4].value*15 + cards[3].value;
  }
  if (cards[1].value == mid && cards[3].value == mid) {
    return 5000000 + mid * 15*15 + cards[4].value*15 + cards[0].value;
  }
  if (cards[3].value == mid && cards[4].value == mid) {
    return 5000000 + mid * 15*15 + cards[1].value*15 + cards[0].value;
  }
 
  // two pairs
  if (cards[1].value == cards[2].value && cards[3].value == cards[4].value) {
    return 4000000 + 15 * 15 * cards[3].value + 15*cards[1].value + cards[0].value;
  }
  if (cards[0].value == cards[1].value && cards[3].value == cards[4].value) {
    return 4000000 + 15 * 15 * cards[3].value + 15*cards[1].value + cards[2].value;
  }
  if (cards[0].value == cards[1].value && cards[2].value == cards[3].value) {
    return 4000000 + 15 * 15 * cards[3].value + 15*cards[1].value + cards[4].value;
  }
 
  // pair
  if (CV(0) == CV(1)) {
    return 3000000 + 15*15*15*CV(0) + 15*15*CV(4) + 15*CV(3) + CV(2);
  }
  if (CV(1) == CV(2)) {
    return 3000000 + 15*15*15*CV(1) + 15*15*CV(4) + 15*CV(3) + CV(0);
  }
  if (CV(2) == CV(3)) {
    return 3000000 + 15*15*15*CV(2) + 15*15*CV(4) + 15*CV(1) + CV(0);
  }
  if (CV(3) == CV(4)) {
    return 3000000 + 15*15*15*CV(3) + 15*15*CV(2) + 15*CV(1) + CV(0);
  }
 
  // one card
  return 15*15*15*15*CV(4) + 15*15*15*CV(3) + 15*15*CV(2) + 15*CV(1) + CV(0);
}
 
 
int get_score(const player& pl, const card table[])
{
  // try all possibilities
  card allcards[7] = {pl.cards[0], pl.cards[1]};
  FOR(i,0,4) allcards[i+2] = table[i];
 
  int bestScore = 0;
 
  FOR(i,0,6) {
    FOR(j,i+1,6) {
      // skip i and j
      card cards[5];
      int nextIdx = 0;
      FOR(k,0,6) {
	if (k != i && k != j) {
	  cards[nextIdx++] = allcards[k];
	}
      }
      sort(cards, cards+4);
      int sc = get_score(cards);
      bestScore = max(bestScore, sc);
    }
  }
 
  return bestScore;
}
 
 
void printvec(vector<int> v)
{
  FOREACH(i,v) {
    cerr << *i << " ";
  }
}
 
void print_card(const card& c)
{
  cerr << c.value << c.color << " ";
}
 
 
 
int main(void)
{
    int playersCnt;
    GETI(playersCnt);
 
    while (!feof(stdin)) {
 
//       cerr << "---------------------------------------" << endl;
//       cerr << "playersCnt: " << playersCnt << endl;
 
      card table[5];
      FOR(i,0,4) {
	char val, color;
	scanf("%c %c ", &val, &color);
	table[i] = card(val, color);
      }
//       cerr << "Table: "; FOR(i,0,4) print_card(table[i]); cerr << endl;
 
      vector<player> players(playersCnt);
      FOR(i,0,playersCnt-1) {
	player pl;
	FOR(j,0,1) {
	  char val, color;
	  scanf("%c %c ", &val, &color);
	  pl.cards[j] = card(val, color);
	}
	players[i] = pl;
 
// 	cerr << "Player " << i << ": "; FOR(j,0,1) print_card(pl.cards[j]); cerr << endl;
      }
 
 
 
      // --------------------------------------------------
 
      vector<int> bestPlayers;
      int bestScore = 0;
      FOR(i,0,playersCnt-1) {
	int score = get_score(players[i], table);
	if (score > bestScore) {
	  bestScore = score;
	  bestPlayers.clear();
	  bestPlayers.push_back(i);
	}
	else if (score == bestScore) {
	  bestPlayers.push_back(i);
	}
// 	cerr << "i: " << i << ", bestPlayers: "; printvec(bestPlayers); cerr << endl;
      }
 
//       cerr << "best score: " << bestScore << endl;
 
      if (bestPlayers.size() == 1) {
	cout << bestPlayers[0]+1 << endl;
      }
      else {
	cout << bestPlayers[0]+1;
	FOR(i,1,(int)bestPlayers.size()-1) {
	  cout << " " << bestPlayers[i]+1;
	}
	cout << endl;
      }
 
 
 
      GETI(playersCnt);
    }
 
 
 
 
    return 0;
}