采用三级队列调度策略，其中一级队列采用非抢占式短作业优先，二级队列采用轮转时间片，三级队列采用FCFS，进程的到达时间和运行时间随机生成，按照时间顺序执行进程，优先级抢占，低队列进程进入后可抢占高队列，要正确输出进程调度过程，所有进程结束后输出甘特图,计算并输出响应时间、周转时间、等待时间等详细，给出cpp代码

以下是采用C++实现的三级队列调度策略代码，包括进程调度过程的输出以及甘特图、响应时间、周转时间、等待时间等详细计算：

#include <iostream>
#include <queue>
#include <vector>
#include <iomanip>
#include <ctime>
using namespace std;

struct Process {
    int pid;
    int arrival_time;
    int burst_time;
    int priority;
    int start_time;
    int end_time;
    int wait_time;
    int turnaround_time;
    int remaining_time;
    Process(int p, int at, int bt, int pri) : pid(p), arrival_time(at), burst_time(bt), priority(pri) {
        remaining_time = burst_time;
    }
};

// 按到达时间排序，用于加入就绪队列
struct ArrivalTimeCompare {
    bool operator() (const Process& p1, const Process& p2) const {
        return p1.arrival_time > p2.arrival_time;
    }
};

// 按优先级排序，用于一级队列
struct PriorityCompare {
    bool operator() (const Process& p1, const Process& p2) const {
        return p1.priority < p2.priority;
    }
};

int main() {
    srand(time(nullptr)); // 用当前时间作为随机数种子

    // 生成10个进程，到达时间和运行时间随机生成
    vector<Process> processes;
    for (int i = 1; i <= 10; i++) {
        int arrival_time = rand() % 10;
        int burst_time = rand() % 10 + 1;
        int priority = rand() % 5 + 1;
        processes.emplace_back(i, arrival_time, burst_time, priority);
    }

    // 输出生成的进程信息
    cout << "进程信息：" << endl;
    cout << "PID\t到达时间\t运行时间\t优先级" << endl;
    for (auto& p : processes) {
        cout << p.pid << "\t" << p.arrival_time << "\t\t" << p.burst_time << "\t\t" << p.priority << endl;
    }
    cout << endl;

    // 三个就绪队列
    queue<Process> q1, q2, q3;

    // 按到达时间排序
    priority_queue<Process, vector<Process>, ArrivalTimeCompare> arrival_time_queue;
    for (auto& p : processes) {
        arrival_time_queue.push(p);
    }

    int time = 0; // 当前时间
    vector<Process> finished_processes; // 已完成的进程
    while (!arrival_time_queue.empty() || !q1.empty() || !q2.empty() || !q3.empty()) {
        // 将到达时间小于等于当前时间的进程加入一级队列
        while (!arrival_time_queue.empty() && arrival_time_queue.top().arrival_time <= time) {
            q1.push(arrival_time_queue.top());
            arrival_time_queue.pop();
        }

        // 一级队列采用非抢占式短作业优先
        if (!q1.empty()) {
            Process p = q1.front();
            q1.pop();

            // 记录开始时间
            if (p.remaining_time == p.burst_time) {
                p.start_time = time;
            }

            // 执行进程
            if (p.remaining_time > 1) {
                p.remaining_time--;
                q2.push(p); // 如果还没执行完，加入二级队列
            }
            else {
                p.remaining_time--;
                p.end_time = time;
                finished_processes.push_back(p); // 如果执行完了，加入已完成进程列表
            }
        }
        // 二级队列采用轮转时间片
        else if (!q2.empty()) {
            Process p = q2.front();
            q2.pop();

            // 记录开始时间
            if (p.remaining_time == p.burst_time) {
                p.start_time = time;
            }

            // 执行进程
            if (p.remaining_time > 2) {
                p.remaining_time -= 2;
                q3.push(p); // 如果还没执行完，加入三级队列
            }
            else {
                p.remaining_time--;
                p.end_time = time;
                finished_processes.push_back(p); // 如果执行完了，加入已完成进程列表
            }

            // 时间片轮转
            if (!q2.empty()) {
                q2.push(p);
            }
        }
        // 三级队列采用FCFS
        else if (!q3.empty()) {
            Process p = q3.front();
            q3.pop();

            // 记录开始时间
            if (p.remaining_time == p.burst_time) {
                p.start_time = time;
            }

            // 执行进程
            p.remaining_time--;
            if (p.remaining_time == 0) {
                p.end_time = time;
                finished_processes.push_back(p); // 如果执行完了，加入已完成进程列表
            }
            else {
                q3.push(p); // 如果还没执行完，加入三级队列尾部
            }
        }

        time++; // 时间自增
    }

    // 输出已完成的进程信息
    cout << "已完成的进程信息：" << endl;
    cout << "PID\t到达时间\t运行时间\t开始时间\t结束时间\t等待时间\t周转时间\t响应时间" << endl;
    int total_wait_time = 0, total_turnaround_time = 0, total_response_time = 0;
    for (auto& p : finished_processes) {
        p.wait_time = p.start_time - p.arrival_time;
        p.turnaround_time = p.end_time - p.arrival_time;
        p.response_time = p.start_time - p.arrival_time;
        total_wait_time += p.wait_time;
        total_turnaround_time += p.turnaround_time;
        total_response_time += p.response_time;
        cout << p.pid << "\t" << p.arrival_time << "\t\t" << p.burst_time << "\t\t" << p.start_time << "\t\t" << p.end_time << "\t\t" << p.wait_time << "\t\t" << p.turnaround_time << "\t\t" << p.response_time << endl;
    }
    cout << endl;

    // 输出甘特图
    cout << "甘特图：" << endl;
    for (auto& p : finished_processes) {
        cout << "P" << p.pid << " [" << setw(2) << p.start_time << ", " << setw(2) << p.end_time << "] ";
    }
    cout << endl;

    // 输出平均等待时间、平均周转时间、平均响应时间
    cout << "平均等待时间：" << static_cast<double>(total_wait_time) / finished_processes.size() << endl;
    cout << "平均周转时间：" << static_cast<double>(total_turnaround_time) / finished_processes.size() << endl;
    cout << "平均响应时间：" << static_cast<double>(total_response_time) / finished_processes.size() << endl;

    return 0;
}