【数据结构OJ】F : A DS队列_动物收容所

Description

有一家动物收容所只收容猫与狗，且严格遵守先进先出原则。在收养该收容所的动物时，收养人只能收养猫或狗，且收养的那一只动物必须是那种动物中剩下未被收养的最先进入收养所的那一只动物。换而言之，收养人不能自由挑选想收养的对象。

题目保证编号number为非负整数，且每次提供的编号比前一次的编号大。

实现AnimalShelf类：

1. void enqueue(int number, string type)：收养所接收编号为number的动物，type为"cat"或"dog"。

2. void dequeueAny(int* number, string* type)：收养人接受收养猫或狗，但是收养所给予的动物必须是剩下的动物中最先进入收养所的那一只。将动物编号与动物种类分别放置在number[0]和type[0]里。

3. int dequeueDog()：收养人只接受收养狗，收养所给予的狗必须是所有剩下的狗之中最先进入收养所的那一只。

4. int dequeueCat()：收养人只接收收养猫，规定同上。

Input

第一行输入t，表示有t个测试样例。

第二行起，首先输入n，表示会执行n个操作，接着输入n个操作。

如果输入的操作是字符串"enqueue"，则该操作接下来还会输入一个非负整数number和一个字符串type，type为"cat"或"dog"；

如果输入的是字符串"dequeueDog"、"dequeueCat"或"dequeueAny"，则该操作不会输入其他内容。

以此类推，共输入t个测试样例。

Output

每一行输出在执行"dequeueDog"、"dequeueCat"和"dequeueAny"操作后所获得的动物，输出格式是"[number type]"。

如果无法领养到对应的动物，则输出"[-1 none]"。

注意输出末尾的空格。

Hint

0 <= number <= 1000

题目保证每次提供的编号比前一次的编号大。

Sample

samplein

3
5 enqueue 0 cat enqueue 1 cat dequeueCat dequeueDog dequeueAny
6 enqueue 0 cat enqueue 1 cat enqueue 2 dog dequeueDog dequeueCat dequeueAny
13 dequeueAny dequeueDog dequeueCat enqueue 20 cat dequeueAny enqueue 30 dog dequeueAny enqueue 50 cat enqueue 60 dog dequeueAny enqueue 70 cat dequeueAny dequeueAny

sampleout

[0 cat] [-1 none] [1 cat] 
[2 dog] [0 cat] [1 cat] 
[-1 none] [-1 none] [-1 none] [20 cat] [30 dog] [50 cat] [60 dog] [70 cat] 

分析

这个实现使用两个队列分别管理猫和狗，根据规则在不同的队列中入队和出队。根据操作执行相应的方法，并输出结果。

AC代码

已经尽量详细的注释了

#include <iostream>
#include <string>
#include <queue>

using namespace std;

// 定义AnimalShelf类
class AnimalShelf {
public:
    // 构造函数，初始化收容所
    AnimalShelf() {
    }

    // 添加动物到收容所
    void enqueue(int number, string type) {
        if (type == "cat") {
            cats.push({ number, type });  // 将猫添加到猫队列
        }
        else if (type == "dog") {
            dogs.push({ number, type });  // 将狗添加到狗队列
        }
    }

    // 从收容所中领养任意一只动物
    void dequeueAny(int* number, string* type) {
        if (!cats.empty() && (dogs.empty() || cats.front().first < dogs.front().first)) {
            // 如果猫队列不为空且狗队列为空或者最早到达的猫比最早到达的狗早
            *number = cats.front().first;  // 获取最早到达的猫的编号
            *type = cats.front().second;    // 获取猫的类型
            cats.pop();                     // 从猫队列中移除该猫
        }
        else if (!dogs.empty()) {
            *number = dogs.front().first;  // 获取最早到达的狗的编号
            *type = dogs.front().second;    // 获取狗的类型
            dogs.pop();                     // 从狗队列中移除该狗
        }
        else {
            *number = -1;                   // 如果没有动物可供领养，编号为-1
            *type = "none";                 // 类型为"none"
        }
    }

    // 从收容所中领养一只狗
    int dequeueDog() {
        if (!dogs.empty()) {
            int dogNumber = dogs.front().first;  // 获取最早到达的狗的编号
            dogs.pop();                         // 从狗队列中移除该狗
            return dogNumber;                   // 返回狗的编号
        }
        else {
            return -1;  // 如果没有狗可供领养，返回-1
        }
    }

    // 从收容所中领养一只猫
    int dequeueCat() {
        if (!cats.empty()) {
            int catNumber = cats.front().first;  // 获取最早到达的猫的编号
            cats.pop();                         // 从猫队列中移除该猫
            return catNumber;                   // 返回猫的编号
        }
        else {
            return -1;  // 如果没有猫可供领养，返回-1
        }
    }

private:
    // 用队列来管理猫和狗，队列中存储了动物的编号和类型
    queue<pair<int, string>> cats;  // 用于存储猫
    queue<pair<int, string>> dogs;  // 用于存储狗
};

int main() {
    int t;
    cin >> t;  // 读取测试用例数量

    while (t--) {
        int n;
        cin >> n;  // 读取每个测试用例的操作数量

        AnimalShelf shelter;  // 创建一个AnimalShelf对象，即动物收容所
        for (int i = 0; i < n; ++i) {
            string operation;
            cin >> operation;  // 读取操作类型

            if (operation == "enqueue") {
                int number;
                string type;
                cin >> number >> type;  // 读取动物的编号和类型
                shelter.enqueue(number, type);  // 调用enqueue方法将动物添加到收容所
            }
            else if (operation == "dequeueDog") {
                int number = shelter.dequeueDog();  // 调用dequeueDog方法领养一只狗
                if (number == -1) {
                    cout << "[" << number << " none] ";  // 输出领养结果
                }
                else
                    cout << "[" << number << " dog] ";
            }
            else if (operation == "dequeueCat") {
                int number = shelter.dequeueCat();  // 调用dequeueCat方法领养一只猫
                if (number == -1) {
                    cout << "[" << number << " none] ";  // 输出领养结果
                }
                else
                    cout << "[" << number << " cat] ";
            }
            else if (operation == "dequeueAny") {
                int number;
                string type;
                shelter.dequeueAny(&number, &type);  // 调用dequeueAny方法领养任意一只动物
                cout << "[" << number << " " << type << "] ";  // 输出领养结果
            }
        }

        cout << endl;  // 换行，处理下一个测试用例
    }

    return 0;
}