6-5 热心的动物饲养员FINAL (30分)

小城动物收容所为被遗弃的老虎、狼和羊提供住所。以前的饲养员一直是一个笼子放一个动物，接任的饲养员不想继续这样。他觉得这样太浪费空间，因为一个笼子本来就是设计来放两只动物的，并且动物有一个伴也会不寂寞。决定把两只动物放进一个笼子饲养。已知同类动物不相食，老虎吃狼和羊，狼吃羊。现在有5个笼子，每个笼子有两个床位，已知按照0，1，2，3，4顺序依次找合适的笼子，床位安排顺序是先一号床位，再二号床位。床位安排完成后，不再调整，即使另一床位空出。

现实现程序完成动物床位的安排，程序将在有动物找不到合适床位时终止。

每行输入包括一个数字和一个字符串。数字是操作类型：1指安排老虎，2是安排羊，3是安排狼，4是动物搬离收容所。接下来的字符串是要操作的动物名字，假设每一个正被收容的动物和即将加入收容所的动物都有一个与众不同的名字。

对于每行输入可能是0行，1行或2行输出。

（1）当待安排的动物找不到合适的床位时，不输出，程序终止。 （2）当安排的动物找到床位时，输出一行，给出它所安排的笼子；如果同笼已经入住了伙伴，则在下一行输出伙伴的名字。 （3）在移除动物时，如果查不到指定的动物，则输出"NOT found!"，如果找到，则输出两行，第一行给出它当前所在的笼号，第二行说明它被"removed!"，这时该动物所在床位重置为空。

函数接口定义：

补齐4个类Cage, Tiger, Sheep, Wolf，可能包括类声明和成员函数。
实现普通函数：void remove(Cage*cage, string& name);

裁判测试程序样例：

#include <iostream>
#include <string>
using namespace std;
#define C 5

class Animal{
    public:
       string name;
       Animal(string name):name(name){ }
       virtual bool eat(Animal&)=0;
       virtual int getType()=0;
};

class Cage{
        Animal *a1, *a2;
        void setAnimal1(Animal&);
        void setAnimal2(Animal&);
   public:
        Cage();
        bool arrange(Animal&);
        bool remove(string&);
        Animal* getRoommate(Animal&);        
};

bool Cage::arrange(Animal& a){
    if(a1==NULL && a2==NULL) {
        setAnimal1(a);
        return true;
    }
    if(a1==NULL && a2!=NULL && !a2->eat(a) && !a.eat(*a2)){
        setAnimal1(a);
        return true;
    }
    if(a1!=NULL && !a1->eat(a) && !a.eat(*a1) && a2==NULL){
        setAnimal2(a);
       return true;
    }
    return false;
}

/* 请在这里填写答案 */

bool arrange(Cage* cage, Animal& a){
    int i;
    Animal *p;
    for(i=0;i<C;i++){
        if(!cage[i].arrange(a)) continue;
        cout<<"cage:"<<i<<endl;
        p=cage[i].getRoommate(a);
        if(p!=NULL) cout<<"roommate:"<<p->name<<endl;
        return true;
    }
    return false;        
}

 

int main(){
    Cage cage[C];
    Wolf *pW;
    Tiger *pT;
    Sheep *pS;
    string name;
    bool state=true;
    int type;

while(cin>>type){
        cin>>name;
        switch(type){
            case 1: pT= new Tiger(name); state=arrange(cage, *pT); break;
            case 2: pS= new Sheep(name); state=arrange(cage, *pS); break;
            case 3: pW= new Wolf(name); state=arrange(cage, *pW); break;
            case 4: remove(cage, name); break;
        }
        if(!state) break;
    }
    return 0;
}

输入样例：

4 Alice
1 Alice
2 Jim
4 Alice
1 Kate
3 John
1 Mike
1 Tony
1 Karl
1 Marry
1 Linda
2 Joan
2 Abel

输出样例：

Alice NOT found!
cage:0
cage:1
cage:0
Alice removed!
cage:0
cage:2
cage:0
roommate:Kate
cage:3
cage:3
roommate:Tony
cage:4
cage:4
roommate:Marry
cage:1
roommate:Jim

输出说明，第一步要移除Alice，因为Alice不在收容所，所以输出NOT found!；第二步将Alice收容入第0笼；第三步将Jim收容入第1笼；第四步要移除Alice，这时找到了Alice，所以输出两行；第五步收容Kate，将它加入第0笼；第6步收容John，将它加入第2笼；第7步收容Mike，将它加入第0笼，接下来输出它的室友名字；第8步收容Tony，将其加入第3笼，第9步收容Karl；将其加入第3笼，同时输出其室友名；第10步收容Marry，将它加入第4笼；第11步收容Linda，将其加入第4笼，同时输出其室友名；第12步收容Joan，将其收容到第1笼，并输出室友名。第13步收容Abel，已经无法找到合适的笼子，程序不输出任何信息，直接结束。

#include <iostream>
#include <string>
using namespace std;
#define C 5
class Animal {//题目给定，先不动
public:
    string name;
    Animal(string name) :name(name) { }
    virtual bool eat(Animal&) = 0;
    virtual int getType() = 0;
};
class Cage {
    Animal* a1, * a2;
    void setAnimal1(Animal&);
    void setAnimal2(Animal&);
public:
    Cage();
    bool arrange(Animal&);
    bool remove(string&);
    Animal* getRoommate(Animal&);
};
bool Cage::arrange(Animal& a) {
    if (a1 == NULL && a2 == NULL) {
        setAnimal1(a);
        return true;
    }
    if (a1 == NULL && a2 != NULL && !a2->eat(a) && !a.eat(*a2)) {
        setAnimal1(a);
        return true;
    }
    if (a1 != NULL && !a1->eat(a) && !a.eat(*a1) && a2 == NULL) {
        setAnimal2(a);
        return true;
    }
    return false;
}
/* 请在这里填写答案 */

/*由于Animal中的两个纯虚函数在派生类中实现方法相同，
因此定义一个新类一起实现，以免在派生类中重复定义*/
class AnimalImpl :public Animal {
private:
    int type;
public:
    AnimalImpl(string name, int _type):Animal(name) {
        type = _type;
    }
    bool eat(Animal& animal) {//不是同类都不能关在一起
        if (type != animal.getType()) return true;
        else return false;
    }
    int getType() {
        return type;
    }
};
class Tiger :public AnimalImpl {
public:   
    Tiger(string n) :AnimalImpl(n,1) {}
};
class Wolf :public AnimalImpl {
public:
    Wolf(string n) :AnimalImpl(n, 2) {}
};
class Sheep :public AnimalImpl {
public:
    Sheep(string n) :AnimalImpl(n, 3) {}
};
//实现Cage类中声明的成员函数
Cage::Cage() {a1 = NULL; a2 = NULL;}
void Cage::setAnimal1(Animal& a) {a1 = &a;}
void Cage::setAnimal2(Animal& a) {a2 = &a;}
Animal* Cage::getRoommate(Animal& a) {
    if (a1 != NULL && a1->name != a.name) return a1;
    else if (a2 != NULL && a2->name != a.name) return a2;
    else return NULL;
}
bool Cage::remove(string& name) {
        if (a1!=NULL&&a1->name == name) {
            a1=NULL;
            return true;
        }else if(a2 != NULL && a2->name == name){
            a2=NULL;
            return true;
        }
        else {
            return false;
        }
}
//主程序中调用的remove
void remove(Cage* cage, string name) {
    int flg = 1;
    for (size_t i = 0; i < C; i++)
    {
        if (cage[i].remove(name)) { cout << "cage:" << i << endl; flg = 0; break; }
    }
    if(flg)cout << name << " NOT found!" << endl;
    else cout << name << " removed!\n";
}
/*以上是自己解答的部分，结束，以下是题目给定的部分*/
bool arrange(Cage* cage, Animal& a) {
    int i;
    Animal* p;
    for (i = 0; i < C; i++) {
        if (!cage[i].arrange(a)) continue;
        cout << "cage:" << i << endl;
        p = cage[i].getRoommate(a);
        if (p != NULL) cout << "roommate:" << p->name << endl;
        return true;
    }
    return false;
}

int main() {
    Cage cage[C];
    Wolf* pW;
    Tiger* pT;
    Sheep* pS;
    string name;
    bool state = true;
    int type;
    while (cin >> type) {
        cin >> name;
        switch (type) {
        case 1: pT = new Tiger(name); state = arrange(cage, *pT); break;
        case 2: pS = new Sheep(name); state = arrange(cage, *pS); break;
        case 3: pW = new Wolf(name); state = arrange(cage, *pW); break;
        case 4: remove(cage, name); break;
        }
        if (!state) break;
    }
    return 0;
}