HDU2094 产生冠军

产生冠军

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

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

解题思路:这道题我用了STL容器中的set,就是把所有赢的人的名字存入set容器中,然后用了两个双重循环遍历,如果赢的人中有曾经输过的,就从set中删除,最后判断如果容器大小为

一就输出yes,否则输出no;

另外有一个小坑点就是最后要用clear()清理set容器,不然会wa;

代码如下(AC):

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
using namespace std;
set<string> v1;
int main(){
    string str1[1010],str2[1010];
    int n;
    while(cin>>n,n){
        for(int i=0;i<n;i++){
            cin>>str1[i]>>str2[i];
            v1.insert(str1[i]);
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(str1[i]==str2[j])
                v1.erase(str1[i]);
            }
        }
        if(v1.size()==1)
        printf("Yes\n");
        else printf("No\n");
        v1.clear();
    }
    return 0;
}

顺便补一下STL的set容器知识:

在set中每个元素的值都唯一,而且系统能根据元素的值自动进行排序。应该注意的是set中数元素的值不能直接被改变。

set使用方法:

begin()     ,返回set容器的第一个迭代器

end()      ,返回set容器的最后一个迭代器

clear()        ,删除set容器中的所有的元素

empty()    ,判断set容器是否为空

max_size()   ,返回set容器可能包含的元素最大个数

size()      ,返回当前set容器中的元素个数

rbegin     ,返回的值和end()相同

rend()     ,返回的值和rbegin()相同

简单的操作实例:

#include <iostream>
#include <set>  

using namespace std;  

int main()
{
    set<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    cout<<"set 的 size 值为 :"<<s.size()<<endl;
    cout<<"set 的 maxsize的值为 :"<<s.max_size()<<endl;
    cout<<"set 中的第一个元素是 :"<<*s.begin()<<endl;
    cout<<"set 中的最后一个元素是:"<<*s.end()<<endl;
    s.clear();
    if(s.empty())
    {
        cout<<"set 为空 !!!"<<endl;
    }
    cout<<"set 的 size 值为 :"<<s.size()<<endl;
    cout<<"set 的 maxsize的值为 :"<<s.max_size()<<endl;
    return 0;
}

小结:插入3之后虽然插入了一个1,但是我们发现set中最后一个值仍然是3哈,这就是set 。还要注意begin() 和 end()函数是不检查set是否为空的,使用前最好使用empty()检验一下set是否为空.

count()方法:

count() 用来查找set中某个某个键值出现的次数。这个函数在set并不是很实用,因为一个键值在set只可能出现0或1次,这样就变成了判断某一键值是否在set出现过了。

实例代码:

#include <iostream>
#include <set>  

using namespace std;  

int main()
{
    set<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    cout<<"set 中 1 出现的次数是 :"<<s.count(1)<<endl;
    cout<<"set 中 4 出现的次数是 :"<<s.count(4)<<endl;
    return 0;
}

erase()方法:

erase(iterator)  ,删除定位器iterator指向的值

erase(first,second),删除定位器first和second之间的值

erase(key_value),删除键值key_value的值

#include <iostream>
#include <set>  

using namespace std;  

int main()
{
    set<int> s;
    set<int>::const_iterator iter;
    set<int>::iterator first;
    set<int>::iterator second;
    for(int i = 1 ; i <= 10 ; ++i)
    {
        s.insert(i);
    }
    //第一种删除
    s.erase(s.begin());
    //第二种删除
    first = s.begin();
    second = s.begin();
    second++;
    second++;
    s.erase(first,second);
    //第三种删除
    s.erase(8);
    cout<<"删除后 set 中元素是 :";
    for(iter = s.begin() ; iter != s.end() ; ++iter)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    return 0;
}

小结:set中的删除操作是不进行任何的错误检查的,比如定位器的是否合法等等,所以用的时候自己一定要注意。

find()方法:

find()  ,返回给定值值得定位器,如果没找到则返回end()。

#include <iostream>
#include <set>

using namespace std;

int main()
{
    int a[] = { 4, 6, 2 , 3};
    set<int> s(a,a + 4);
    set<int>::iterator iter;
    for(iter = s.begin();iter != s.end();iter++)
    {
        cout << *iter << "  " ;
    }
    cout << endl;
    if((iter = s.find(2)) != s.end())
        cout<<*iter<<endl;
    if((iter = s.find(1)) != s.end())
        cout<<*iter<<endl;

    return 0;
}

运行结果:

2 3 4 6

2

小结:find(x)是返回的是x的值,如果x没有在set中则会输出end();

lower_bound(key_value) ,返回第一个大于等于key_value的定位器

upper_bound(key_value),返回最后一个大于key_value的定位器

#include <iostream>
#include <set>

using namespace std;

int main()
{
    set<int> s;
    for(int i = 1;i <= 5;i ++)
    {
        int x;
        cin >> x;
        s.insert(x);
    }
    set<int>::iterator iter;
    for(iter = s.begin() ; iter != s.end() ; ++iter)
    {
        cout << *iter << " ";
    }
    cout << endl;
    cout << "第一个大于等于 2 的值是:   ";
        cout<<*s.lower_bound(2)<<endl;
    cout << "第一个大于等于 3 的值是:   ";
        cout<<*s.lower_bound(3)<<endl;
    cout << "第一个大于 3 的值是:   ";
        cout<<*s.upper_bound(3)<<endl;
    return 0;
}

原文地址:https://www.cnblogs.com/jianqiao123/p/11329908.html

时间: 2024-10-10 11:06:21

HDU2094 产生冠军的相关文章

HDU2094 产生冠军 【STL】

产生冠军 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 8523    Accepted Submission(s): 4009 Problem Description 有一群人,打乒乓球比赛,两两捉对撕杀,每两个人之间最多打一场比赛. 球赛的规则如下: 如果A打败了B,B又打败了C,而A与C之间没有进行过比赛,那么就认定,A一定能打

hdu2094 产生冠军 (set)

//set不会有重复的元素 # include <stdio.h> # include <algorithm> # include <string> # include <map> # include <set> # include <iostream> using namespace std; int main() { char a[1010],b[1010]; set<string>q1;//全部的人 set<s

hdu2094——产生冠军

产生冠军 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 9274    Accepted Submission(s): 4359 Problem Description 有一群人,打乒乓球比赛,两两捉对撕杀,每两个人之间最多打一场比赛. 球赛的规则如下: 如果A打败了B,B又打败了C,而A与C之间没有进行过比赛,那么就认定,A一定能打

hdu2094—看似拓扑实际上是一道思维题

HDU2094  产生冠军 题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2094 题意:中文题,就不解释了.题意已经非常清楚了. 这道题的看起来像是一个拓扑排序的问题实际上拓扑感觉做不了,可能可以做了吧?但是我没想到,估计也比较麻烦吧.这里介绍一种比较简单的做法,就是一种思维,如果存在冠军(所有人都可以被他打败),这个人肯定没有败过,而其他人都败过,所以我们只需要确定所有人的人数,和败者的人数(去重以后,所以需要用set,因为一个败者会败给多个人

《程序设计技术》课程辅助学习资料

本文档提供课程相关的辅助学习资料. 阅读程序是提高程序设计水平的最为有效的方法,<程序设计技术>课程至少应该阅读后面提供链接博文中的基础部分.能够阅读完基础部分的博文,则可以给课程学习奠定一个坚实的基础. 自己编写程序也是学习编程必不可少的一个环节.自己编写是否正确可以通过OJ系统来验证.选做OJ的程序设计题方便于评价自己所写的程序是否正确.想要提高编写程序的能力并且达到更高的水平,从各个OJ中选做一些编程题是十分必要的. 文中提供了CCF-CSP认证考试历年 试题的第1题的题解.这些题解中都

算法学习——STL和基本数据结构

第一次接触算法,只是照着自己的方法学习的,总结写的可能不是会很好,但我会努力改进. #STL容器包括顺序式容器和关联式容器. 顺序式容器: ·vector:动态数组,从末尾能快速插入与删除,直接访问任何元素. ·list:双链表,从任何地方快速插入与删除. ·deque:双向队列,从前面或后面快速插入与删除,直接访问任何元素. ·queue:队列,先进先出 ·priority_queue:优先队列,最高优先级元素总是第一个出列. ·stack:栈,先进后出. 关联式容器: ·set:集合,快速查

HDU2094(产生冠军)题解

HDU2094(产生冠军)题解 以防万一,题目原文和链接均附在文末.那么先是题目分析: [一句话题意] 根据给定现有比赛结果推断分析冠军.(这描述...我建议还是看题吧,题不长) [题目分析] 给出的数据是每两个选手之间的关♂系,于是以为是简单链表,后来感觉是并查集,再后来才发现都不科学.于是换了一个特别科学普通简单粗暴可爱的方法.在说方法之前,我想吐槽几句.这道题似乎不够严谨.数据里如果有一组是a>b;b>c;c>a;d>e的话,这将分为两个不相关的组合.这种情况我感觉应该输出的

hdu2094(产生冠军)

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

HDU2094:产生冠军

产生冠军 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 11500    Accepted Submission(s): 5334 Problem Description 有一群人,打乒乓球比赛,两两捉对撕杀,每两个人之间最多打一场比赛. 球赛的规则如下: 如果A打败了B,B又打败了C,而A与C之间没有进行过比赛,那么就认定,A一定能