HDOJ 2094 产生冠军

产生冠军

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5027    Accepted Submission(s): 2409

Problem Description

有一群人，打乒乓球比赛，两两捉对撕杀，每两个人之间最多打一场比赛。
球赛的规则如下：
如果A打败了B，B又打败了C，而A与C之间没有进行过比赛，那么就认定，A一定能打败C。
如果A打败了B，B又打败了C，而且，C又打败了A，那么A、B、C三者都不可能成为冠军。
根据这个规则，无需循环较量，或许就能确定冠军。你的任务就是面对一群比赛选手，在经过了若干场撕杀之后，确定是否已经实际上产生了冠军。

 

Input

输入含有一些选手群，每群选手都以一个整数n(n<1000)开头，后跟n对选手的比赛结果，比赛结果以一对选手名字（中间隔一空格）表示，前者战胜后者。如果n为0，则表示输入结束。

 

Output

对于每个选手群，若你判断出产生了冠军，则在一行中输出“Yes”，否则在一行中输出“No”。

 

Sample Input

3 Alice Bob Smith John Alice Smith 5 a c c d d e b e a d 0

 

Sample Output

Yes No

 

/* 功能Function Description:        HDOJ-2094   
   开发环境Environment:                DEV C++ 4.9.9.1
   技术特点Technique:
   版本Version:
   作者Author:                        可笑痴狂
   日期Date:                        20120812
   备注Notes:                -----策略问题

*/

/*
代码一：
本来想先用字典树给名字编号，然后用建立相应的邻接表，枚举每个节点然后DFS，后来发现一直wrong，看看网上的思路，
发现只用判断是否存在唯一一个没有被打败的人即可，就根据邻接表判断的。
*/

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct node
{
    int code;
    struct node *next1;
}node;
node c[2001];

typedef struct tree
{
    int order;
    struct tree *next2[26];
}tree;

tree memory[1000000];
int k,m; 
int visit[1001];

int insert(char *a,tree *T)
{
    tree *p,*q;
    int i,j,id,flag=0;
    p=T;
    i=0;
    while(a[i])
    {
        id=a[i]-'a';
        if(p->next2[id]==NULL)
        {
            flag=1;
            q=&memory[k++];
            q->order=0;
            for(j=0;j<26;++j)
                q->next2[j]=NULL;
            p->next2[id]=q;
        }
        p=p->next2[id];
        ++i;
    }
    if(flag||p->order==0)
    {
        p->order=m++;
        return p->order;
    }
    else
        return p->order;
}

/*
void DFS(int i)
{
    struct node *t;
    for(t=c[i].next1;t;t=t->next1)
    {
        if(visit[t->code])
            continue;
        visit[t->code]=1;
        DFS(t->code);
    }
}
*/

int main()
{
    int n,i,flag,num1,num2;
    char a[30],b[30];
    tree *T;
    node *t1;
    T=&memory[0];
    while(scanf("%d",&n),n)
    {    
        k=1;
        m=1;
        T->order=0;
        for(i=0;i<26;++i)
            T->next2[i]=NULL;
        for(i=1;i<=2*n;++i)
        {
            c[i].next1=NULL;
            c[i].code=i;
        }
        for(i=1;i<=n;++i)
        {
            scanf("%s%s",a,b);
            num1=insert(a,T);
            num2=insert(b,T);
            
            t1=(node *)malloc(sizeof(node));
            t1->code=num1;
            t1->next1=c[num2].next1;
            c[num2].next1=t1;
        }
         
        flag=0;
        for(i=1;i<m;++i)
        {
            if(c[i].next1==NULL)
                ++flag;
            if(flag>1)
                break;
        }
        if(flag==1)
            printf("Yes\n");
        else
            printf("No\n");
        /*
        for(i=1;flag&&i<=n;++i)
        {
            for(j=1;j<=n;++j)
                visit[j]=0;
            DFS(i);
            if(visit[i])
            {
                flag=0;
                break;
            }
            for(j=1;j<=n;++j)
            {
                if(j==i)
                    continue;
                if(visit[j]==0)
                {
                    flag=0;
                    break;
                }
            }
            if(j==n+1)
                break;
        }
        if(flag)
            printf("Yes\n");
        else
            printf("No\n");
        */
    }
    return 0;
}



/*
//代码二：
题目要求产生冠军，其实，仔细看一下题目就可以知道，其实冠军的产生很简单，就是所给的数据中存在唯一没有被打败的人，
而对于谁打败谁，根本没有关系。换句话说，只要把所有名字列出来，并记录他们分别被打败的次数，
再从头到尾查一下总共多少人没有被打败过，如果只有一个人 那就yes了。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct tree
{
    int order;
    struct tree *next[26];
}tree;

tree memory[1000000];
int k,m; 
int num[2005];

int insert(char *a,tree *T)
{
    tree *p,*q;
    int i,j,id,flag=0;
    p=T;
    i=0;
    while(a[i])
    {
        id=a[i]-'a';
        if(p->next[id]==NULL)
        {
            flag=1;
            q=&memory[k++];
            q->order=0;
            for(j=0;j<26;++j)
                q->next[j]=NULL;
            p->next[id]=q;
        }
        p=p->next[id];
        ++i;
    }
    if(flag||p->order==0)
    {
        p->order=m++;
        return p->order;
    }
    else
        return p->order;
}


int main()
{
    int n,i,flag,num1,num2;
    char a[30],b[30];
    tree *T;
    T=&memory[0];
    while(scanf("%d",&n),n)
    {    
        k=1;
        m=1;
        flag=0;
        memset(num,0,sizeof(num));
        T->order=0;
        for(i=0;i<26;++i)
            T->next[i]=NULL;
        for(i=1;i<=n;++i)
        {
            scanf("%s%s",a,b);
            num1=insert(b,T);
            num2=insert(a,T);
            num[num1]++;
        }
        for(i=1;i<m;++i)
        {
            if(num[i]==0)
                ++flag;
            if(flag>1)
                break;
        }
        if(flag==1)
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}

*/