南邮 OJ 1091 Black Vienna

Black Vienna

时间限制(普通/Java) : 1000 MS/ 3000 MS          运行内存限制 : 65536 KByte
总提交 : 53            测试通过 : 17 

比赛描述

This problem is based on the game of Black Vienna. In this version there are three players and 18 cards labeled A-R. Three of the cards are set aside (hidden) and form the "Black Vienna" gang. The remaining
cards are shuffled and dealt to the players so that each player has 5 cards. Players never reveal their cards to each other. There is a separate deck of "interrogation cards" which contain three distinct letters in ascending order, like ACG or BHR.  Turns
rotate through players 1, 2, and 3.  On each player's turn, that player selects an interrogation card, puts it face up in front of another player, and that other player must indicate the total number of these cards being held, without saying which ones.  All
players see the result of the "interrogation". The play continues until a player deduces the three cards in the "gang".     

For example, suppose the cards are distributed as follows, and the game then proceeds:

Player 1: DGJLP; Player 2: EFOQR; Player 3: ACHMN;  Gang: BIK

Turn 1:  Player 1 interrogates player 2 with BJK; answer 0

Turn 2:  Player 2 interrogates player 3 with ABK; answer 1

Turn 3:  Player 3 interrogates player 2 with DEF; answer 2

Turn 4:  Player 1 interrogates player 2 with EIL; answer 1

Turn 5:  Player 2 interrogates player 3 with FIP; answer 0

Turn 6:  Player 3 interrogates player 1 with GMO; answer 1

Turn 7:  Player 1 interrogates player 2 with OQR; answer 3

Turn 8:  Player 2 interrogates player 3 with ADQ; answer 1

Turn 9:  Player 3 interrogates player 1 with EGJ; answer 2

In fact, the game does not need to get to turn 9.  With enough thought, player 1 can deduce after turn 8 that the gang is BIK.  It is your job to analyze records of games and deduce the earliest time that the gang could be determined for sure.

输入

The input will consist of one to twelve data sets, followed by a line containing only 0.   

The first line of a dataset contains the number, t, of turns reported, 2 ≤ t ≤ 15.  

The next line contains four blank separated strings for the hands of players 1, 2, and 3, followed by the cards for the gang.

The remaining t lines of the data set contain the data for each turn in order.  Each line contains three blank separated tokens:  the number of the player interrogated, the string of interrogation letters, and the answer provided.

All letter strings will contain only capital letters from A to R, in strictly increasing alphabetical order.  The same interrogation string may appear in more than one turn of a game.

输出

There is one line of output for each data set.  The line contains the single character "?" if no player can be sure of
the gang after all the turns listed.  If a player can determine the gang, the line contains the earliest turn after which one or more players can be sure of the answer.

样例输入

9

DGJLP EFOQR ACHMN BIK

2 BJK 0

3 ABK 1

2 DEF 2

2 EIL 1

3 FIP 0

1 GMO 1

2 OQR 3

3 ADQ 1

1 EGJ 2

3

ABCDE FGHIJ KLMNO PQR

3 BKQ 1

1 ADE 3

2 CHJ 2

0

样例输出

8

?

题目来源

ACM Mid-Central Regional 2009

#include<iostream>
using namespace std;

const int PLAYERS = 3, // check against final problem statement!
MAX_TURNS = 15,
HAND = 5,
HID = 3,
UNK = HID+HAND*(PLAYERS-1);

int turns;

char quest[MAX_TURNS][3+1], // interrogations
hand[PLAYERS + 1][5+1], //actual hands, gang at end
maybe[PLAYERS + 1][HAND+1]; //possible hands, gang

char unk[UNK]; // letters not in one player's hand

int who[MAX_TURNS], // who interrogated
matches[MAX_TURNS], // matches in interogation
used[PLAYERS+1]; // amount of maybe hand filled

int solved; // max turns needed for current player for comb. so far

int Max(int a,int b);
void solve(int i,char unk[]);
int countConsistent(char choice[][HAND+1]);
int countDups(char a1[],char a2[]);

int main()
{
//freopen("in.txt","r",stdin);
int i,j;
int bestSolved;
while(scanf("%d",&turns)!=EOF && turns>0)
{
for(i=0;i<=PLAYERS;i++)
scanf("%s",&hand[i]);
int t;
for(t=0;t<turns;t++)
{
scanf("%d",&who[t]);
who[t]--; // internal 0 based
scanf("%s",&quest[t]);
scanf("%d",&matches[t]);
}
bestSolved=MAX_TURNS;
int p;
char unkStr[18-5+1];
for(p=0;p<PLAYERS;p++)
{
memset(unkStr,'\0',sizeof(unkStr));
for(j=0;j<=PLAYERS;j++){
if(j!=p)
strcat(unkStr,hand[j]);
}
strcpy(maybe[p],hand[p]); // player knows own
used[p] = HAND; // no further characters to choose
solved = 0; // after recursion max turns to eliminate a maybe
solve(0,unkStr);
memset(maybe[p],'\0',sizeof(maybe[p]));
used[p]=0;
if(solved<bestSolved)
bestSolved=solved;
}
if(bestSolved<turns)
printf("%d\n",bestSolved+1);
else
printf("?\n");
}//end while
return 0;
}//end main()

int Max(int a,int b)
{ return (a>b)?a:b; }

// accumulate combinations recursively, check when one is complete
void solve(int i,char unk[])
{
if(i==(18-5)){ // assigned all choices, now check
if (maybe[PLAYERS][0] == unk[i-HID]) return; //match end gang char
solved = Max(solved, countConsistent(maybe));
}
else{
int j;
for(j=0;j<=PLAYERS;j++){
if((j<PLAYERS && used[j]<5) || (j==PLAYERS && used[j]<3)){ //add char to partial hand
maybe[j][used[j]]=unk[i];
used[j]++;
solve(i+1,unk);
used[j]--; // undo change before trying next player
}
}
}
}

// return first inconsistent turn (0 based) or total turns if consistent
int countConsistent(char choice[][HAND+1])
{
int t=0;
while(t<turns &&
countDups(choice[who[t]],quest[t])==matches[t])
t++;
return t;
}

int countDups(char a1[],char a2[])
{
int i,j;
int n=0;
for(i=0;i<5;i++){
for(j=0;j<3;j++)
if(a1[i]==a2[j])
n++;
}
return n;
}