K - Rochambeau（POJ2912）

N children are playing Rochambeau (scissors-rock-cloth) game with you. One of them is the judge. The rest children are divided into three groups (it is possible that some group is empty). You don’t know who is the judge, or how the children are grouped. Then the children start playing Rochambeau game for M rounds. Each round two children are arbitrarily selected to play Rochambeau for one once, and you will be told the outcome while not knowing which gesture the children presented. It is known that the children in the same group would present the same gesture (hence, two children in the same group always get draw when playing) and different groups for different gestures. The judge would present gesture randomly each time, hence no one knows what gesture the judge would present. Can you guess who is the judge after after the game ends? If you can, after how many rounds can you find out the judge at the earliest?

Input

Input contains multiple test cases. Each test case starts with two integers N and M (1 ≤ N ≤ 500, 0 ≤ M ≤ 2,000) in one line, which are the number of children and the number of rounds. Following are M lines, each line contains two integers in [0, N) separated by one symbol. The two integers are the IDs of the two children selected to play Rochambeau for this round. The symbol may be “=”, “>” or “<”, referring to a draw, that first child wins and that second child wins respectively.

Output

There is only one line for each test case. If the judge can be found, print the ID of the judge, and the least number of rounds after which the judge can be uniquely determined. If the judge can not be found, or the outcomes of the M rounds of game are inconsistent, print the corresponding message.

Sample Input

3 3
0<1
1<2
2<0
3 5
0<1
0>1
1<2
1>2
0<2
4 4
0<1
0>1
2<3
2>3
1 0

Sample Output

Can not determine
Player 1 can be determined to be the judge after 4 lines
Impossible
Player 0 can be determined to be the judge after 0 lines

【题意】

n个小朋友玩剪刀石头布，分成3组，其中有一个裁判，同一组的小朋友每次出相同的手势，只有裁判每次出的手势是随机的，从进行m轮游戏，已知每轮游戏后的结果，输出裁判的序号，并且输出至少经过几轮游戏才能判断出该人是裁判，如果没有裁判则输出Impossible，如果裁判数量过多不能确定则输出Can not determine。

【解题思路】

将每局比赛的结果量化为0，1，2，用并查集去维护，枚举0-n-1个人分别是裁判的情况，并且除去和裁判游戏的轮数，如果node[j].op!=(sum[node[j].a]-sum[node[j].b]+3)%3则说明这个人不是裁判，标记一下，最后找出为没被标记的序号则是裁判。

【代码】

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=505;
int pre[maxn],sum[maxn],f[maxn],index[maxn];
int n,m;
struct Node
{
    int op,a,b;
} node[2005];
int findroot(int x)
{
    if(x!=pre[x])
    {
        int t=pre[x];
        pre[x]=findroot(pre[x]);
        sum[x]=(sum[x]+sum[t]+3)%3;
    }
    return pre[x];
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        int a,b,ans=0,ansindex=0,cnt=0;
        char ch;
        memset(f,1,sizeof(f));
        memset(index,0,sizeof(index));
        for(int i=0; i<m; i++)
        {
            scanf("%d%c%d",&a,&ch,&b);
            if(ch=='=')
                node[i].op=0;
            else if(ch=='>')
                node[i].op=1;
            else
                node[i].op=2;
            node[i].a=a;
            node[i].b=b;
        }
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
                pre[j]=j;
            memset(sum,0,sizeof(sum));
            for(int j=0; j<m; j++)
            {
                if(node[j].a==i || node[j].b==i)
                    continue;
                int fa=findroot(node[j].a);
                int fb=findroot(node[j].b);
                if(fa!=fb)
                {
                    pre[fa]=fb;
                    sum[fa]=(sum[node[j].b]-sum[node[j].a]+node[j].op+3)%3;
                }
                else
                {
                    if(node[j].op!=(sum[node[j].a]-sum[node[j].b]+3)%3)
                    {
                        f[i]=0;
                        index[i]=j+1;
                        break;
                    }
                }
            }
        }
        for(int i=0; i<n; i++)
        {
            if(f[i])
            {
                cnt++;
                ans=i;
            }
            else
                ansindex=max(ansindex,index[i]);
        }
        if(cnt==1)
            printf("Player %d can be determined to be the judge after %d lines\n",ans,ansindex);
        else if(cnt>1)
            printf("Can not determine\n");
        else if(cnt==0)
            printf("Impossible\n");
    }
    return 0;
}