问题描述 假设某银行有4个窗口对外接待客户，从早晨银行开门（开门9：00am，关门5：00pm）起不断有客户进入银行。由于每个窗口在某个时刻只能接待一个客户，因此在客户人数众多时需要在每个窗口前顺次排队，对于刚进入银行的客户（建议：客户进入时间使用随机函数产生），如果某个窗口的业务员正空闲，则可上前办理业务；反之，若4个窗口均有窗户所占，他便会排在人数最少的队伍后面。 任务要求： 1)编制一个程序以模拟银行的这种业务活动并计算一天中客户在银行逗留的平均时间。 2)建议有如下设置： a)客户到达时间随机产生，一天客户的人数设定为100人。b)银行业务员处理时间随机产生，平均处理时间10分钟。3)将一天的数据（包括业务员和客户）以文件方式输出。用c++编写，提高效率

以下是基本的 C++ 代码示例，实现了题目要求的功能：

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <ctime>
#include <queue>
#include <vector>

using namespace std;

const int numWindows = 4;  // 窗口数量
const int totalCustomers = 100;  // 客户总数
const int openTime = 9 * 60;  // 开门时间（分钟）
const int closeTime = 17 * 60;  // 关门时间（分钟）
const int secondsPerMin = 60;  // 每分钟的秒数

// 客户类
class Customer {
public:
    int id;
    int arriveTime;  // 到达时间
    int startTime;  // 开始办理时间
    int finishTime;  // 完成时间
    int waitTime;  // 等待时间
};

// 按到达时间升序排序的客户队列
class ArrivalQueue : public queue<Customer> {
public:
    void push(const Customer& c) {
        if (empty()) {
            queue<Customer>::push(c);
        } else {
            queue<Customer>::push(c);
            vector<Customer> temp;
            while (front().arriveTime > c.arriveTime && !empty()) {
                temp.push_back(front());
                pop();
            }
            queue<Customer>::push(c);
            for (int i = 0; i < temp.size(); ++i) {
                queue<Customer>::push(temp[i]);
            }
        }
    }
};

// 按等待时间升序排序的客户队列
class WaitQueue : public queue<Customer> {
public:
    void push(const Customer& c) {
        if (empty()) {
            queue<Customer>::push(c);
        } else {
            queue<Customer>::push(c);
            vector<Customer> temp;
            while (front().waitTime > c.waitTime && !empty()) {
                temp.push_back(front());
                pop();
            }
            queue<Customer>::push(c);
            for (int i = 0; i < temp.size(); ++i) {
                queue<Customer>::push(temp[i]);
            }
        }
    }
};

// 随机生成一个客户
Customer generateCustomer(int id, int lastArriveTime) {
    Customer c;
    c.id = id;
    c.arriveTime = lastArriveTime + rand() % 10 + 1;  // 随机生成到达时间
    c.waitTime = 0;
    return c;
}

// 随机生成一个业务员的处理时间（秒）
int generateProcessTime() {
    return rand() % 600 + 300;  // 平均处理时间为10分钟
}

int main() {
    srand(time(nullptr));
    ofstream fout("bank.txt");  // 输出文件

    ArrivalQueue arrivalQueue;  // 按到达时间排序的客户队列
    vector<WaitQueue> windowQueues(numWindows);  // 每个窗口的客户队列
    vector<Customer> customers(totalCustomers);  // 所有客户
    int lastArriveTime = openTime;  // 上一个客户到达时间

    // 生成所有客户
    for (int i = 0; i < totalCustomers; ++i) {
        customers[i] = generateCustomer(i + 1, lastArriveTime);
        lastArriveTime = customers[i].arriveTime;
        arrivalQueue.push(customers[i]);
    }

    // 模拟银行业务活动
    int currentTime = openTime;
    int totalWaitTime = 0;
    int totalCustomerTime = 0;
    while (!arrivalQueue.empty() || currentTime < closeTime) {
        // 处理每个窗口的客户
        for (int i = 0; i < numWindows; ++i) {
            if (!windowQueues[i].empty()) {
                Customer c = windowQueues[i].front();
                if (currentTime - c.startTime >= c.finishTime) {
                    c.finishTime = currentTime;
                    totalCustomerTime += c.finishTime - c.arriveTime;
                    windowQueues[i].pop();
                }
            }
        }

        // 将到达时间小于等于当前时间的客户加入窗口队列
        while (!arrivalQueue.empty() && arrivalQueue.front().arriveTime <= currentTime) {
            Customer c = arrivalQueue.front();
            arrivalQueue.pop();

            // 找到队列长度最短的窗口
            int minWaitIndex = 0;
            for (int i = 1; i < numWindows; ++i) {
                if (windowQueues[i].size() < windowQueues[minWaitIndex].size()) {
                    minWaitIndex = i;
                }
            }

            // 将客户加入队列并记录开始办理时间
            c.startTime = currentTime;
            c.finishTime = generateProcessTime() / secondsPerMin;
            windowQueues[minWaitIndex].push(c);
            totalWaitTime += currentTime - c.arriveTime;
        }

        ++currentTime;
    }

    // 输出所有客户的信息
    fout << "ID\tArrive Time\tStart Time\tFinish Time\tWait Time" << endl;
    for (int i = 0; i < totalCustomers; ++i) {
        fout << customers[i].id << "\t" << customers[i].arriveTime / 60 << ":" << customers[i].arriveTime % 60
            << "\t" << customers[i].startTime / 60 << ":" << customers[i].startTime % 60 << "\t"
            << customers[i].finishTime / 60 << ":" << customers[i].finishTime % 60 << "\t"
            << customers[i].waitTime / 60 << ":" << customers[i].waitTime % 60 << endl;
    }

    // 输出平均逗留时间和平均等待时间
    fout << "Average Customer Time: " << totalCustomerTime / totalCustomers / 60 << " minutes" << endl;
    fout << "Average Wait Time: " << totalWaitTime / totalCustomers / 60 << " minutes" << endl;

    fout.close();
    return 0;
}

程序首先生成所有客户，并按到达时间排序加入到客户队列中。在模拟银行业务活动时，程序通过循环处理每个窗口的客户并将到达时间小于等于当前时间的客户加入到窗口队列中。每个窗口的客户队列是按等待时间升序排序的，因此程序总是从队列长度最短的窗口中取出客户进行办理。程序还记录了每个客户的等待时间、开始办理时间、完成时间和逗留时间，并输出到文件中。最后，程序输出平均逗留时间和平均等待时间。