2006 年百度之星程序设计大赛初赛题目 4

厚积薄发

剪刀石头布

# U. Z1 x; Z$ S) D3 c& m/ F6 [N 个小孩正在和你玩一种剪刀石头布游戏。 N 个小孩中有一个是裁判，其余小孩分成三组（不排除某些组没有任何成员的可能性），但是你不知道谁是裁判，也不知道小孩们的分组情况。然后，小孩们开始玩剪刀石头布游戏，一共玩 M 次，每次任意选择两个小孩进行一轮，你会被告知结果，即两个小孩的胜负情况，然而你不会得知小孩具体出的是剪刀、石头还是布。已知各组的小孩分别只会出一种手势（因而同一组的两个小孩总会是和局），而裁判则每次都会随便选择出一种手势，因此没有人会知道裁判到底会出什么。请你在 M 次剪刀石头布游戏结束后，猜猜谁是裁判。如果你能猜出谁是裁判，请说明最早在第几次游戏结束后你就能够确定谁是裁判。
" e$ F# i( U: C
1 G2 t2 L1 v: z% f输入格式：
- S1 ^* @9 q7 Z( `
输入文件包含多组测试数据。每组测试数据第一行为两个整数 N 和 M （ 1 ≤ N ≤ 500 ， 0 ≤ M ≤ 2000 ），分别为小孩的个数和剪刀石头布游戏进行的次数。接下来 M 行，每行两个整数且中间以一个符号隔开。两个整数分别为进行游戏的两个小孩各自的编号，为小于 N 的非负整数。符号的可能值为“ = ”、“ > ”和“ < ”，分别表示和局、第一个小孩胜和第二个小孩胜三种情况。

  D4 \! B5 i+ P6 N( [1 @4 j输出格式：

* z' ]+ T; z+ z$ u+ d/ Z每组测试数据输出一行，若能猜出谁是裁判，则输出身为裁判的小孩的编号，并输出在第几次游戏结束后就能够确定谁是裁判。如果无法确定谁是裁判，或者发现剪刀石头布游戏的胜负情况不合理（即无论谁是裁判都会出现矛盾），则输出相应的信息。具体输出格式请参考输出样例。

# ^( b  H7 s) b' m输入样例

4 Y" r0 y) x' A" M' J3 3
4 D* I. j7 @8 R+ Q2 `
0<1

1<2
  m0 U/ [: [* }, E* ~' c
2<0
  g) b; u$ k8 w5 d' ?
3 5
( D$ m; E6 E! p+ ^! r$ t5 Y
, h% T9 V$ b4 y0<1
! i: U6 H3 z5 _) P9 C3 a% @+ D
0>1
- G2 ?  w1 J/ k3 s9 n
& X: M9 y7 V2 U" [1<2

1>2
# Y# q. B3 q( m: E( p( r
0<2

4 4
+ M3 d: s  \  J7 M+ I
. w! N+ U. z6 k) A6 [! Z0<1
3 [2 m# P/ c7 e; f: h: A
0>1

2<3
& j( `  z5 Y" h/ C: R" s/ o4 P9 L
8 C$ |! ?7 u% h8 \; T6 D' ~0 f2>3
) h% P0 Y: C; Z+ I1 [% d
1 0
! q. k4 x- B4 e; n

; x# g% V6 P. s8 T; N& T+ `输出样例

7 K, L% o$ J9 c: z7 @. s0 `
0 b4 ^, Y1 J* ]1 M" o9 O0 hCan not determine
/ o8 u4 x6 e2 n
Player 1 can be determined to be the judge after 4 lines
: V5 o! I* I. q; V! x+ q* ~, I1 K
Impossible
( i2 K3 I* k- U
Player 0 can be determined to be the judge after 0 lines
! x/ i+ Y& A, c5 \$ H
7 I) p2 K( b) I5 b7 c3 d9 `0 \  u6 u

9 @, l0 r* i8 v1 q/ \
5 Z' z& j7 Q. }' U4 c7 P5 t2 x
说明：

8 u) O6 Y% X0 c% D/ Y共有 5 个测试数据集，每个测试数据集为一个输入文件，包含多组测试数据。每个测试数据集从易到难分别为 5 、 10 、 15 、 30 和 40 分，对每个测试数据集分别执行一次程序，每次必须在运行时限 3 秒内结束程序并输出正确的答案才能得分。

所有数据均从标准输入设备（ stdin/cin ）读入，并写出到标准输出设备 （ stdout/cout ）中。
5 z3 g0 x5 j& u8 o: ^" O
五个测试数据集中输入 N 分别不大于 20 、 50 、 100 、 200 和 500 ，各有 10 组测试数据。
3 K  `# c; ~4 f' y' s' B1 ]8 c% U
; \# b3 _! S) |) A5 z9 F% Qexample1：
$ }3 N3 z& L7 \! c' i
/*剪刀石头布*/
#include <iostream>
+ B  y: l1 [  j! M$ F#include <vector>
7 O! K3 x+ p$ Y1 p- m% n" S( M" Z" a#include <string>
using namespace std;
- }6 q$ h5 Q: c3 ?8 q& o1 ^
struct numNod
* @8 R9 N- o& v{
* u# W" r; x5 \3 d    int value;//小孩的编号
    vector<int> win;//胜出的数字队列 暂定20个 以后编写动态增加数组后再修改
+ X; F7 E* g# W" m. z( j% u8 x2 n    vector<int> lose;//输掉的数字队列 暂定20个 以后编写动态增加数组后再修改
% p9 W; ]+ }/ [/ X) W    numNod *next;
};//如果某个数字结构体的胜出队列中和失败队列中出现二次或者两次以上的同数字结果则说明这个数字是裁判
//另外值得注意的是只有裁判才会出现平局的情况
: w9 y9 S# ?* s* y
class Run
) \, y" s1 H( _5 J, D{
public:
    Run();
    int Compare( int num1, int num2, char sign );
5 d. G- H, E, W( kprivate:
8 w0 r8 ]: B: O( r9 k3 R: X  c    numNod *p;
5 V! v$ |* ~. ~6 ]5 N% `    int CheckUp();//检查函数,检查裁判是否已经得出
    int numOfCheck;//猜拳进行的次数
    numNod* SearchNum( int num );//查找p所指向队列是否有num这个数字结构,有的话返回指向num的地址,没有的话返回的地址是NULL
    void ReworkList( numNod *p, char sign, int num2 );//第一种情况,给出指向数字结构体指针,输赢标志(1,2,3),比较对象(数字)
, c% C6 L% t. v6 V! t: {    void ReworkList( int num1, char sign, int num2 ); //第二种情况,即结构体数字队列没有这个数字要重新生成
- M- O* U0 S) N. z( W. g# I};

& c7 ~4 y8 z, G6 L( }Run::Run()
1 L, q" e2 c5 s# ~{
    this->p = NULL;
, X0 p4 ^. @/ O5 n    this->numOfCheck = 0;
2 B1 [1 H8 T* P$ S7 w* _8 z}
  N( r0 x( V3 {
' J7 w: \) Q5 u7 l+ F: rnumNod* Run::SearchNum( int num )
{
    if( !this->p )
! f& S- d6 ^* ^# v    {
4 q" R0 E6 p! _) ~" L, o& u        return NULL;
    }
7 p5 o6 ^+ t5 a$ F, k# _    else
' y6 C: ]0 o1 ^, y! c- c    {
        numNod *pTmp = this->p;
! E% o1 C% s6 W3 J: q& N7 ~        while( pTmp->value != num && pTmp->next )
            pTmp = pTmp->next;
* M2 I- J* x5 ]: I' ^  {) H, G& G        //至此查找完毕开始检测是否已经找到
- ?% |' h# _% b% K        if( pTmp->value == num )
- U4 I& ~3 i/ L% D! @0 j' e        {
  D: y# j1 Y7 f            return pTmp;
        }
        else
$ J( Q- I) H; ]7 h        {
+ Q& @2 H7 d. W1 c* R6 _            return NULL;
        }
    }
}
& z$ u& Z  A7 k
void Run::ReworkList( numNod *p, char sign, int num2 )
{
    if( sign == '>' )
# D1 p0 I  w/ C- J    {
        p->win.push_back( num2 );
    }
$ c' g3 U* ~% R( _' H: |    else if ( sign == '<' )
    {
# L0 S* p9 k  w6 Y  T6 s        p->lose.push_back( num2 );
    }
    else if( sign == '=' )//平局
    {
! {' N' P( Q! h        p->win.push_back( num2 );
+ ?4 Y- k% U6 H. `4 t        p->lose.push_back( num2 );
3 s7 _" O6 G" e    }
3 S0 q- i( u" G: `, h" h# g6 I& H- d    else//非法比较字符
    {
3 w+ g7 ~. @5 Q$ @( G$ c* K        cout << "Sign Error!" << endl;
! k& C- `7 Q0 Z) P* `% j1 S+ Y& a; H        return;
    }
}

' O1 A5 u6 b6 dvoid Run::ReworkList( int num1, char sign, int num2 )
{
    numNod *pTmp = this->p;

    if( this->p == NULL )
" h2 r8 q2 A7 ~$ o: f    {
" G& E$ [7 i2 K& Y* m        this->p = new numNod;
        this->p->next = NULL;
        this->p->value = num1;
5 U$ g$ ~/ K( t6 g3 w: b2 w        pTmp = this->p;
" B# _* K: E# F  W    }
    else
    {
    while( pTmp->next )
        pTmp = pTmp->next;
    pTmp->next = new numNod;
8 k) U0 e2 q, b8 z    pTmp->next->value = num1;
+ b* n% P  W0 ?' g3 S' q    pTmp->next->next = NULL;
6 C; |# C/ l) i" k% F) M) r3 n    pTmp = pTmp->next;
    }
5 S0 ~$ N6 m$ B7 Z! Z/ x; T   
! O7 C: J) F2 N9 ]" T' e2 V# n/ O    if( sign == '>' )
    {
% d& a+ Z/ q( ]. N) ]        pTmp->win.push_back( num2 );
    }
    else if ( sign == '<' )
    {
4 P+ O$ ^# P! W0 H5 f0 O9 }        pTmp->lose.push_back( num2 );
' b- C% z" b3 \' A/ P# K    }
+ L, ]+ A* u3 B( N    else if( sign == '=' )//平局
    {
        pTmp->win.push_back( num2 );
        pTmp->lose.push_back( num2 );
5 G" ^0 Q2 X0 ]: k+ ^' F    }
    else//非法比较字符
    {
2 ~! U6 D9 d! X$ T- M1 V        cout << "Sign Error!" << endl;
/ {2 F) Z& k7 A! z. p        return;
& {. e7 [0 G5 R# v    }
$ ^% `4 Y( u4 L: ?; |! \}

/ B4 P5 A: K5 [8 W) ^int Run::Compare( int num1, int num2, char sign )
{
1 c8 \# o) ]* [' ]$ Q    numNod *pTmp;
    int result(-1);
! Y" w' A; W0 o   
    //检查队列有没有num1 和 num2  有点话处理 每有生成
    pTmp = this->SearchNum( num1 );
2 G9 [/ _% H; y& u; X$ G) c    if( pTmp )//如果已经有
    {
        this->ReworkList( pTmp, sign, num2 );
; j2 a8 a- B2 A: u    }
    else
    {
! Y8 t* B' f5 v- ^' S        this->ReworkList( num1, sign, num2 );
7 O: w5 D  ?1 b" n! f6 K    }
    //处理第二个数字
    pTmp = this->SearchNum( num2 );
8 a; C: ]' t+ l) I) r' E; Q1 D    if( pTmp )//如果已经有
    {
3 P7 M  b. h+ D7 A        this->ReworkList( pTmp, sign, num1 );
& ?9 n4 W2 C; `# f# r' w; P    }
2 Z. w( g% r/ a    else
    {
+ T* V& Y' V8 j% C- z" L. ^) X        this->ReworkList( num2, sign, num1 );
    }
/ _& c( O* C3 K7 S8 @, {- \    ++ this->numOfCheck;
! I0 |) Q* \1 r, ]( [" |    result = this->CheckUp();
5 x1 e% K8 R: G' g' k# {' Y7 o    if( result != -1 )
1 |  `/ {0 K; O: G    {
        return result;
) f) H, F! L4 P2 d    }
" U4 w6 J8 F4 H$ ]  @. h& i    return -1;
}
& B. ^' B+ @' t: S+ v) k. t
int Run::CheckUp()//返回-1表示没有得出裁判,否则返回裁判的编号
0 B( s- l: i# N6 O( H& W) u9 m5 q{
7 A$ y; j6 ~' `    numNod *pTmp = this->p;
. j! p# ^2 F# Y! @) V    int numOfSame = 0;//win lose列有相同有相同数字的次数
. t5 ?9 Z# ~$ L) z- Q    while( pTmp )
) a7 J4 L$ h5 u+ c    {
; C) P6 k5 |6 t; h/ k/ Q: K        for( vector<int>::size_type i = 0; i < pTmp->win.size(); ++ i )
2 ~2 S' |2 B7 p        {
            for( vector<int>::size_type j = 0; j < pTmp->lose.size(); ++ j )
            {
, k$ {1 l& M" D4 @  D+ E                if( pTmp->win == pTmp->lose[j] )
                    ++ numOfSame;
, C- v( V, v# r( `1 D            }
2 f, N& \$ [( m$ e        }
        if( numOfSame > 1 )
        {
            return pTmp->value;//返回裁判数字编号
        }
- X0 s2 n9 W0 c' R        numOfSame = 0;
        pTmp = pTmp->next;
  }, x9 {! e& ?( A, s  h    }
    return -1;
# U4 K" A" w6 C4 A}

int main()
{
* i; g# k  G- Z4 @    Run example1;
# M# j: |; R6 ~# L. j8 n    cout << "请输入选手人数 和 比赛次数" << endl;
    int num1(0), num2(0);
$ x5 r$ y6 R: Y5 y1 J9 y- c    cin >> num1 >> num2;
/ N( u  k: u; [) U' x    if( num1 == 1 && num2 == 0 )
# k( C& f; v# c+ b4 U    {
        cout << "Player 0 can be determined to be the judge after 0 lines" << endl;
        return 0;
6 C5 e1 A: ^9 b# Q( t( m6 c9 B    }
    else if( num2 == 0 && num1 > 1 )
    {
        cout << "Can not determine " << endl;
7 P( ^4 ]3 f! x2 p7 o8 f: \  C        return 0;
" j* {6 f6 X, J" r8 g& U    }
    cout << "请输入" << num2 << "次的比赛结果,让程序来猜测裁判是谁,输入格式例如 1 < 0" << endl;
' H7 T3 ?, e/ G' V; ^    int num3(0), num4(0);
! h6 G9 m, k% a% R# U    char sign;
0 o2 F% P% K: `5 V    //string string1;
    int comparlines(0);
2 i2 L+ H' i" @- u' `    while( cin >> num3 >> sign >> num4 && comparlines < num2 )
5 M- C) c" o1 T0 P3 S% z1 O    {
, j- r! A" I! u( N        //cout << "Debug:: string1:" << string1 << endl;
        //num3 = string1[0];
2 j3 ?* [" i- f" N$ U: }        //sign = string1[1];
        //num4 = string1[2];
        //cout << "Debug:: num3" << string1[0] << endl;
" e5 a, G0 p1 \' b. J7 V        if( num3 < 0 || num3 > num1 || num4 < 0 || num4 > num1 )
* }; \4 ^( _& W        {
5 V3 f- u. |/ o( Z# S' E            cout << "存在选手编号非法输入,程序退出!" << endl;
            return -1 ;
) d0 K. [0 e9 O$ A9 v+ f        }
        int rs = example1.Compare( num3, num4, sign );
1 V- J0 D2 b+ W4 s" }9 ^6 I        if( rs != -1 )
        {
            cout << "Player" << rs << "can be determined to be the judge after " << comparlines << " lines" << endl;
) O0 j: {( P  A" o/ b6 ^4 Q0 h            return 0;
' X- W- t! Y/ p3 p! ]* T        }
        ++ comparlines;
- U8 s. T9 a+ I8 s0 K( b5 m& L        if( comparlines == num2 )
  k: B5 X( B: }' N- u/ h        {
            cout << " Can not determine " << endl;
            return 0;
        }
    }
" `& S8 C5 n7 [8 p   
8 f6 v% Y6 H+ _/ v! F# c    return 0;
}



、

! C: R' i  Y" |6 l


来源：编程爱好者acm题库

1164678512

Acm惹不起，呵呵

1164678512

Acm惹不起，呵呵

qiuyeliu

eueis 发表于 2011-8-31 17:04
; {5 A& U$ a& P% w8 V" j2 l一起交流！对这个话题感兴趣的朋友们

Acm 一般用C吧

大鲵2003