noip2003提高组之侦探推理

点击下载noip2003提高组题目_代码_测试数据.rar

点击察看关于组合算法的另一篇文章

 

 此题相当锻炼编程的基本功夫，参加Noip的新手不要错过！

 

  1/**//*
  2=========程序信息========
  3对应题目：noip2003提高组_侦探推理
  4使用语言：c++
  5使用编译器：dev c++
  6使用算法：穷举模拟
  7算法运行时间：O(p*C(m,n)) + O(m*C(m,n)) [其中C(m,n)是从m个数中取n个数的组合数]
  8作者：贵州大学05级 刘永辉 
  9昵称：SDJL
 10编写时间：2008年8月
 11联系QQ：44561907
 12E-Mail：44561907@qq.com
 13获得更多文章请访问我的博客：www.cnblogs.com/sdjl
 14如果发现BUG或有写得不好的地方请发邮件告诉我:)
 15=========题目解析========
 16在做此题之前，我们需要搞清楚几点，这是我从测试数据中看出而从题目上不容易看出来的：
 17题目补充点一：如果有4个人a、b、c、d，当a、b说谎话时我们推出了c是罪犯，然后当a、c说谎话时我们又推出了c是罪犯，此时我们仅推出一个罪犯，而不是两个，因此输出为c，而不是输出Cannot Determine，注意不要重复计数。
 18题目补充点二：如果有4个人a、b、c、d，当我们推出a、b、c三人都不是罪犯而d未知时，那么d就是罪犯，这是从某些测试数据中发现的规则，题目没有明说。
 19题目补充点三：不会出现重名情况。
 20题目补充点四：注意“I am guilty.”、“Today is Monday.”等语句的后面均有一个“.”号。
 21
 22在确定上面几点后我们来思考此题如何做，首先我想到的是用模拟方法，并且此程序使用的就是模拟方法，也就是说，我们用组合的方式从m个人中取出n个人假设这n个人说谎话，然后分别对这m个人所说的共p句话进行判断，如果p句话均两两不矛盾的话，那么就看看能不能正好找出一个罪犯，或者正好找出m-1个“好人”的话（“好人”指不是罪犯的人，下同），另一个便认为是罪犯。
 23同时注意分析，本质上有效的证言仅有4种类型，第一种是“谁是罪犯”，第二种是“谁不是罪犯”，第三种是“今天是星期几”，第四种是“今天不是星期几”，并且如果某个说谎者的证言类型为“谁是罪犯”，那么他的反证言“谁不是罪犯”一定成立。
 24无论在这n个人说谎的情况下能不能找出罪犯，都要从m个人中重新找出一组n个人的组合，再次进行判断（即寻找罪犯）。
 25直到所有说谎人的组合情况都考虑后再来看哪些人有可能是罪犯，如果超过两个，则输出Cannot Determine，如果正好有一个，则输出此人的名字，如果一个都没有，则输出Impossible。
 26*/
 27
 28#include <cstdlib>
 29#include <iostream>
 30#include <fstream>
 31
 32using namespace std;
 33const int maxn=20;//最多参与人数
 34const int maxTestimony=100;//最多证词数
 35
 36//证词枚举类型，分别对应“I am guilty.”、“I am not guilty”、“Today is XXX”、“Today not is XXX”及其它废话。
 37enum TestimonyWordsType
 38{
 39    IsGuilty,NotIsGuilty,TodayIs,TodayNotIs,NullWords
 40};
 41//星期枚举类型，分别从“星期一”对应到“星期日”，最后一个是“未知”，注意，枚举事实上是一个从0开始计数的整数，Monday事实上等于0，Tuesday等于1，Unknown等于7，因此后面代码出现诸如“isToday[Monday]=1”的代码时请不要惊讶，这表示今天是星期一
 42enum WeekType
 43{
 44    Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday,Unknown
 45};
 46//证言结构体
 47struct TestimonyStruct
 48{
 49    TestimonyWordsType Words;//证言的类型，IsGuilty、NotIsGuilty、TodayIs、TodayNotIs、NullWords五个之一
 50    TestimonyWordsType Reverse;//证言的反类型，IsGuilty、NotIsGuilty互反，TodayIs、TodayNotIs互反，NullWords的反类型还是NullWords
 51    
 52    int PeopleNum;//说话内容里面所涉及到的人的编号，比如说“SDJL is guilty.”那么就是SDJL此人的编号，此字段仅在Words属于IsGuilty、NotIsGuilty之一时有用
 53    WeekType Week;//说话内容里面所涉及到的星期，比如说“Today is Monday.”那么Week就等于Monday，此字段仅在Words属于TodayIs、TodayNotIs之一时有用
 54
 55    int SpeakerNum;//说话者编号
 56};
 57//人结构体
 58struct PeopleStruct
 59{
 60    string Name;//人名
 61    int Num;//编号
 62};
 63
 64PeopleStruct people[maxn];//人
 65int n;//说谎者人数
 66int m;//总人数
 67int p;//证言数，注意一个人可能有多句证言，或没有证言
 68int StoryPeople[maxn];//StoryPeople[3]=5表示第3个说谎者是people[5]（从第0个开始计数），此全局变量仅用于保存组合算法的状态，其它地方不会用到
 69bool isStoryPeople[maxn];//isStoryPople[5]=true表示第5个人说的是谎话，此全局变量在组合算法中得到它的值，而在验证机中用来判断某人是否说谎话
 70TestimonyStruct testimony[maxTestimony];//证言
 71int guilty[maxn];//guilty[3]=2表示两次推出第3个人是罪犯，等于0表示不能推出此人是罪犯，这里我们不能简单的用一个整数来记录找出的罪犯数以及用一个字符串来记录罪犯的名字，这是因为要避免前面所提到的“题目补充点一”情况。
 72
 73//这两个全局变量用于验证机 
 74int peopleIsGuilty[maxn];//peopleIsGuilty[7]=1表示第7个人是罪犯，=-1表示不是罪犯，=0表示未知 
 75int isToday[7];//isToday[3]=1 表示今天是星期四， isToday[6]=-1 表示今天不是星期日，别忘了是从0开始计数，等于0时表示未知,isToday数组中最多只能有一个为1
 76
 77//根据人名得到此人的编号
 78int GetPeopleNum(string name)//运行时间：O(m) 
 79{
 80    for(int i=0; i<m; i++)    
 81    {
 82        if(people[i].Name == name)
 83            return i;    
 84    }
 85    //这里应该抛出异常，表示给出的人名错误     
 86}
 87
 88//根据星期名称字符串得到星期枚举类型
 89WeekType GetWeekType(string weekString)//运行时间：O(1)
 90{
 91    //字符串居然不能用于switch语句？这是我没有预料到的
 92    WeekType returnWeekType;
 93    if(weekString == "Monday.")
 94    {
 95        returnWeekType = Monday;
 96    }
 97    else if(weekString == "Tuesday.")        
 98    {
 99        returnWeekType = Tuesday;
    }
    else if(weekString == "Wednesday.")
    {
        returnWeekType = Wednesday;    
    }
    else if(weekString == "Thursday.")
    {
        returnWeekType = Thursday;    
    }
    else if(weekString == "Friday.")
    {
        returnWeekType = Friday;    
    }
    else if(weekString == "Saturday.")
    {
        returnWeekType = Saturday;    
    }
    else if(weekString == "Sunday.")
    {
        returnWeekType = Sunday;    
    }
    else 
    {
        returnWeekType = Unknown;
    }
    
    return returnWeekType;
}

//设置证言，speakerNum是说话者编号，testimonyWords是证词，testimony是对应的证言结构体（全局）
//在函数执行前testimony是未知的（即各个字段没有初始化），而在函数执行后testimony是已知的
void SetTestimony(int speakerNum, string testimonyWords, TestimonyStruct &testimony)//运行时间：O(m) [因为调用GetPeopleNum]
{
    //证词的前四个单词，注意证词不包括说话者姓名和姓名后面的“：”符号
    string word1,word2,word3,word4;
    word1 = strtok(&(testimonyWords[0])," ");
    word2 = strtok(NULL," ");
    word3 = strtok(NULL," ");
    //如果第3个单词是not的话才读取第4个单词，这是为了避免一行仅有3个单词时读取第4个单词引起的错误
    if(word3 == "not")
        word4 = strtok(NULL," ");
    else
        word4 = "";
    
    //设置说话者    
    testimony.SpeakerNum = speakerNum;
            
    //如果证言是：“I am guilty.” 
    if((word1 == "I") && (word2 == "am") && (word3 == "guilty."))
    {
        testimony.Words = IsGuilty;//设置证词类型，下同
        testimony.Reverse = NotIsGuilty;//设置证词反类型，下同
        testimony.PeopleNum = speakerNum;//设置证词中出现的人物编号，下同
        testimony.Week = Unknown;//设置证词中出现的星期，下同
    }
    //否则如果证言是：“I am not guilty.” 
    else if((word1 == "I") && (word2 == "am") && (word3 == "not") && (word4 == "guilty."))
    {
        testimony.Words = NotIsGuilty;
        testimony.Reverse = IsGuilty;
        testimony.PeopleNum = speakerNum;
        testimony.Week = Unknown;    
    }
    //否则如果证言是：“XXX 是罪犯”
    else if((word2 == "is") && (word3 == "guilty.")) 
    {
        int guiltyNum = GetPeopleNum(word1);//获得证词中出现的人物编号，下同
        testimony.Words = IsGuilty;
        testimony.Reverse = NotIsGuilty;
        testimony.PeopleNum = guiltyNum;
        testimony.Week = Unknown;    
    }
    //否则如果证言是：“XXX 不是罪犯”
    else if((word2 == "is") && (word3 == "not") && (word4 == "guilty."))
    {
        int guiltyNum = GetPeopleNum(word1);
        testimony.Words = NotIsGuilty;
        testimony.Reverse = IsGuilty;
        testimony.PeopleNum = guiltyNum;
        testimony.Week = Unknown;    
    }
    //否则如果证言是：“今天是星期X”
    else if((word1 == "Today") && (word2 == "is")) 
    {
        WeekType week = GetWeekType(word3);//获得证词中出现的星期，有可能返回的是Unknown
        if(week != Unknown)//增加这句话是为了防止诸如“Today is Good Day.”的废话 
        {
            testimony.Words = TodayIs;
            testimony.Reverse = TodayNotIs;
            testimony.PeopleNum = -1;//因为此时我们不应该使用到此值，所以设置为-1，这样如果不小心使用到这个字段的话会因为引用数组下标出界而抛出异常进而提示我们程序有错误
            testimony.Week =  week;
        }
        else
            testimony.Words = NullWords;
    }
    else//否则证言没有意义
        testimony.Words = NullWords;
} 

//初始化全局变量，从文件中读取数据
void init()//运行时间：O(pm)
{
    ifstream inputFile("logic.in");
    //读取第一行的m,n,p 
    inputFile>>m>>n>>p;
    //读取名字，并初始化people 
    for(int i=0; i<m; i++)//每次运行时间：O(m)
    {
        string name;
        inputFile>>name;
        people[i].Name = name;        
        people[i].Num = i;        
    }
    //申明一个没用的字符串然后使用函数getline(inputFile,temp,'\n')，这是为了让文件读取指针指向下一行的开头
    string temp;
    getline(inputFile,temp,'\n');
    
    //读取p句证词 
    for(int i=0; i<p; i++)//每次运行时间：O(pm)
    {
        //从文件中读取说话者姓名
        string speakerName;
        getline(inputFile,speakerName,':');
        //由姓名得到说话者编号
        int speakerNum = GetPeopleNum(speakerName);//每次运行时间：O(m)
        
        //从文件中读取证词
        string testimonyWords;
        getline(inputFile,testimonyWords,'\n');
        //给第i句证词赋值，注意函数执行前testimony[i]的各个字段是未知的
        SetTestimony(speakerNum,testimonyWords,testimony[i]);//每次运行时间：O(m)
    } 
    inputFile.close();
    
    //我们假设编号从0到n-1的这n个人说谎
    for(int i=0; i<n; i++)//每次运行时间：O(n)
        StoryPeople[i] = i;
    for(int i=0; i<m; i++)//每次运行时间：O(m)
    {
        isStoryPeople[i] = false;    
    }
    
    for(int i=0; i<n; i++)//每次运行时间：O(n)
    {
           isStoryPeople[StoryPeople[i]] = true;
    }

    //初始化全局变量guilty
    for(int i=0; i<n; i++)//每次运行时间：O(n)
        guilty[i] = 0;
}

//初始化证言验证机器，初始化后验证机认为所有的人都是未知的，并且也不知道今天是星期几
void ResetCheckupMachine()//运行时间：O(m)
{
    for(int i=0; i<m; i++)
        peopleIsGuilty[i] = 0;//别忘了等于0表示未知，等于1表示是罪犯，等于-1表示不是罪犯
    for(int i=0; i<7; i++)
        isToday[i] = 0;//类似peopleIsGuilty
}

//验证一句证言，使用前要调用“初始化证言验证机”函数
bool Checkup(TestimonyStruct &testimony)//运行时间：O(1)
{
    //申明用于检验的证词类型
    TestimonyWordsType testimonyWordsType;
    //获得说话者编号
    int speakerNum = testimony.SpeakerNum;
    //如果他说假话
    if(isStoryPeople[speakerNum])
        testimonyWordsType = testimony.Reverse;//用于检验的证词为反证词
    else//否则说真话 
        testimonyWordsType = testimony.Words;

    bool consistent;//consistent=false表示证言不一致（矛盾） 
    //获得证词中所涉及的星期
    int weekNum = testimony.Week;
    //分别考虑证词的每种情况，注意证言验证机把testimonyWordsType看为正确的，哪怕它是由说谎者说出来的
    switch(testimonyWordsType)
    {
        //如果证词是“I am guilty.”类型
        case IsGuilty:
            //假如证言验证机已经确定此人不是罪犯
            if(peopleIsGuilty[testimony.PeopleNum] == -1)
                consistent = false;//证言矛盾
            else
            {
                //否则证言不矛盾
                consistent = true;
                //记下曾经有人说过这个人是罪犯
                peopleIsGuilty[testimony.PeopleNum] = 1;
            }
            break;
        //如果证词是“I am not guilty.”类型
        case NotIsGuilty:
            //假如证言验证机已经确定此人就是罪犯
            if(peopleIsGuilty[testimony.PeopleNum] == 1)
                consistent = false;//证言矛盾
            else
            {
                //否则证言不矛盾
                consistent = true;
                //记下曾经有人说过这个人不是罪犯
                peopleIsGuilty[testimony.PeopleNum] = -1;    
            }            
            break;
        //如果证言是“Today is XXX”类型，不失一般性，下面我们假设XXX代表星期三
        case TodayIs:
            //如果证言验证机已经确定今天不是星期三
            if(isToday[weekNum] == -1)
                consistent = false;//证言矛盾
            else
            {
                //记下今天是星期三
                isToday[weekNum] = 1;
                //count用于记算一共确定了几次星期，比如说上一次确定是星期二，而这一次又确定是星期三，那么count就会在isToday[Tuesday]==1时增加1，和在isToday[Wednesday]==1时增加1
                int count=0;
                for(int i=0; i<7; i++)
                    if(isToday[i] == 1)
                        count++;
                //如果仅确定了一次
                if(count ==1)
                    consistent = true;//证言不矛盾
                else//否则确定过多次
                    consistent = false;//证言矛盾
                /**//*
                Q：为什么不用一个全局变量来记录今天是星期几呢？
                A：因为当遇到证言为“Today is not XXX”时证言验证机需要记下今天不是星期几（及设置isToday[XXX]=-1），而这是用一个全局变量做不到的
                */
            }        
            break;
        //如果证言是：“Today is not XXX”类型，同样，下面我们假设XXX代表星期三
        case TodayNotIs:
            //如果证言验证机已经确定今天就是星期三
            if(isToday[weekNum] == 1)
                consistent = false;//证言矛盾
            else
            {
                //记下今天不是星期三
                isToday[weekNum] = -1;
                //证言不矛盾
                consistent = true;
            }            
            break;
        default:
            //对于其它废话我们认为它与所有证言都不矛盾
            consistent = true;
            break;        
    }
    //返回此句证言是否矛盾
    return consistent;
}

//计算下一组说谎话的人，当所有组合均依次出现后函数返回false，关于组合算法请参考我的另一篇文章 
bool NextGroupStoryPeople()//运行时间：O(m) [注意m>n]
{
    bool hasNext;
    
    int k = n - 1;
    while ((k >= 0) && (StoryPeople[k] + (n - k) == m))
    {
        k--;
    }
    if (k>=0)
    {
       if (k==n-1)
       {
           StoryPeople[k]++;
       }
       else
       {
            StoryPeople[k]++;
            k++;
            while (k<n)
            {
                StoryPeople[k] = StoryPeople[k - 1] + 1;
                k++;
            }
       }
       hasNext = true;
       //计算说谎的人，别忘了StoryPeople用来保存组合的状态，便于生成下一个组合，并不用于其它函数，而isStoryPeople在验证证言时会用到
       for(int i=0; i<m; i++)//每次运行时间：O(m)
       {
            isStoryPeople[i] = false;    
       }
       for(int i=0; i<n; i++)
       {
            isStoryPeople[StoryPeople[i]] = true;
       }
    }
    else
    {
        hasNext = false;
    }
    return hasNext;    
}

//运行整个模拟查找过程
void run()//运行时间：O(p*C(m,n))+O(m*C(m,n)) [是否等于O((m+p)*C(m,n))???]
{
    
    do//运行时间：C(m,n)*(O(p)+O(m))
    {        
        //重置证言验证机，以便开始验证接下来的证言
        ResetCheckupMachine();     //每次运行时间：O(m)
        
        
        bool consistent = true;//consistent=false表示证言出现矛盾 
        //依次验证p句证言
        for(int i=0; i<p; i++)//每次运行时间：O(p)
        {
            consistent = Checkup(testimony[i]);//每次运行时间：O(1)
            //如果证言出现矛盾
            if(!consistent)
                break;//跳出验证循环
        } 
        //如果证言不矛盾 
        if(consistent)
        {
            //统计罪犯数
            int guiltyCount=0;
            for(int i=0; i<m; i++)//每次运行时间：O(m)
            {
                //如果第i个人是罪犯，注意peopleIsGuilty在每次重置证言验证机时被初始化
                if(peopleIsGuilty[i] == 1)
                {
                    //罪犯数增加1
                    guiltyCount++;    
                }
            }    
            //如果根据证言能够恰好有一个罪犯（表示在这次由n个人组成说谎者的情况下正好找到了一个罪犯）
            if(guiltyCount == 1)
            {
                //寻找到那个罪犯
                for(int i=0; i<m; i++)//每次运行时间：O(m)
                {
                    if(peopleIsGuilty[i] == 1)
                    {
                        guilty[i]++;//此步不懂的话到申明处看看guilty的注释
                        break;
                    }
                }    
            }    
            else//否则不能恰好找到一个罪犯（根据题目补充点四，我们判断是否恰好有m-1个人不是罪犯）
            {
                //统计不是罪犯的人数
                int notGuiltyCount = 0;
                for(int i=0; i<m; i++)//每次运行时间：O(m)
                {
                    if(peopleIsGuilty[i] == -1)
                    {
                        notGuiltyCount++;    
                    }
                }    
                //如果根据证言能够恰好有m-1个人不是罪犯
                if(notGuiltyCount == m-1)
                {
                    //找出那个不能推出是不是罪犯的人
                    for(int i=0; i<m; i++)//每次运行时间：O(m)
                    {                        
                        if(peopleIsGuilty[i] != -1)
                        {
                            //那么我们认为他是罪犯
                            guilty[i]++;
                            break;
                        }
                    }    
                }            
            }
        }
    }while(NextGroupStoryPeople());//直到所有说谎组合均考虑过后。运行次数C(m,n),NextGroupStoryPeople运行时间为：O(m) 
    /**//*
    我们也可以在找到两个罪犯时退出模拟寻找过程以便提高程序效率，因为题目要求当能找到多于1个罪犯时仅输出“Cannot Determine”
    */
}

//输出结果，此函数说明略
void show()//运行时间：O(m)
{
    int guiltyCount = 0;
    string guiltyName;

    for(int i=0; i<m; i++)
    {
        if(guilty[i]>0)
        {
            guiltyCount++;
            guiltyName = people[i].Name;
        }
    }
    switch(guiltyCount)
    {
        case 0:
            cout<<"Impossible"<<endl;
            break;    
        case 1:
            cout<<guiltyName<<endl;
            break;
        default:
            cout<<"Cannot Determine"<<endl;
            break;
    }
    
}

int main(int argc, char *argv[])//运行时间：O(p*C(m,n))+O(m*C(m,n))
{
    init();//初始化全局变量，从输入文件中读取数据
    run();//运行模拟查找过程
    show();//输出结果
    system("PAUSE");
    return EXIT_SUCCESS;
}