进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。用C++实现，考虑到达时间

好的，我了解了你的问题。这是一个关于进程调度算法的问题，需要实现一个采用最高优先数优先和先来先服务算法的调度程序。每个进程有一个进程控制块（PCB）表示，包含进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等信息。进程的优先数和需要的运行时间可以人为指定或由随机数产生。进程的状态有就绪、运行和完成三种，用时间片为单位计算运行时间。如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，否则将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。

下面是一个可能的C++实现，考虑到到达时间：

#include <iostream>
#include <queue>
#include <string>
#include <ctime>
using namespace std;

// 进程控制块
struct PCB {
    string name;  // 进程名
    int priority;  // 优先数
    int arrivalTime;  // 到达时间
    int requiredTime;  // 需要运行时间
    int usedTime;  // 已用CPU时间
    char state;  // 进程状态：W(ait)、R(un)、F(inish)
};

// 生成随机数
int random(int min, int max) {
    return rand() % (max - min + 1) + min;
}

// 比较函数，用于进程优先级的比较
bool operator<(const PCB& a, const PCB& b) {
    return a.priority < b.priority;
}

// 进程调度函数
void schedule(int n) {
    // 初始化就绪队列
    priority_queue<PCB> readyQueue;
    for (int i = 0; i < n; i++) {
        PCB pcb;
        pcb.name = "P" + to_string(i);
        pcb.priority = random(1, 10);
        pcb.arrivalTime = random(0, 10);
        pcb.requiredTime = random(1, 5);
        pcb.usedTime = 0;
        pcb.state = 'W';
        readyQueue.push(pcb);
    }

    // 打印初始状态
    cout << "Time 0:" << endl;
    cout << "Running: NULL" << endl;
    cout << "Ready: ";
    priority_queue<PCB> q = readyQueue;
    while (!q.empty()) {
        cout << q.top().name << "(" << q.top().priority << ") ";
        q.pop();
    }
    cout << endl;
    for (int i = 0; i < n; i++) {
        PCB pcb = readyQueue.top();
        readyQueue.pop();
        cout << pcb.name << "\tPriority: " << pcb.priority << "\tArrivalTime: " << pcb.arrivalTime
             << "\tRequiredTime: " << pcb.requiredTime << "\tUsedTime: " << pcb.usedTime
             << "\tState: " << pcb.state << endl;
        readyQueue.push(pcb);
    }

    // 执行调度
    int time = 0;
    PCB running;
    while (true) {
        // 判断是否所有进程都已完成
        bool allFinished = true;
        priority_queue<PCB> q = readyQueue;
        while (!q.empty()) {
            if (q.top().state != 'F') {
                allFinished = false;
                break;
            }
            q.pop();
        }
        if (allFinished) {
            break;
        }

        // 判断是否有新进程到达
        priority_queue<PCB> newQueue;
        while (!readyQueue.empty() && readyQueue.top().arrivalTime <= time) {
            PCB pcb = readyQueue.top();
            pcb.state = 'W';
            newQueue.push(pcb);
            readyQueue.pop();
        }
        while (!newQueue.empty()) {
            readyQueue.push(newQueue.top());
            newQueue.pop();
        }

        // 选择下一个进程运行
        if (running.state != 'F') {
            running.state = 'W';
            readyQueue.push(running);
        }
        if (!readyQueue.empty()) {
            running = readyQueue.top();
            running.state = 'R';
            readyQueue.pop();
        } else {
            running.name = "NULL";
            running.priority = 0;
            running.arrivalTime = 0;
            running.requiredTime = 0;
            running.usedTime = 0;
            running.state = 'F';
        }
        running.usedTime++;

        // 打印状态
        cout << "Time " << time + 1 << ":" << endl;
        cout << "Running: " << running.name << endl;
        cout << "Ready: ";
        q = readyQueue;
        while (!q.empty()) {
            cout << q.top().name << "(" << q.top().priority << ") ";
            q.pop();
        }
        cout << endl;
        for (int i = 0; i < n; i++) {
            PCB pcb = readyQueue.top();
            readyQueue.pop();
            cout << pcb.name << "\tPriority: " << pcb.priority << "\tArrivalTime: " << pcb.arrivalTime
                 << "\tRequiredTime: " << pcb.requiredTime << "\tUsedTime: " << pcb.usedTime
                 << "\tState: " << pcb.state << endl;
            readyQueue.push(pcb);
        }

        // 判断进程是否完成
        if (running.usedTime == running.requiredTime) {
            running.state = 'F';
        } else {
            running.priority--;
            if (running.priority < 1) {
                running.priority = 1;
            }
            readyQueue.push(running);
        }

        // 时间片加1
        time++;
    }
}

int main() {
    srand(time(NULL));
    int n;
    cout << "Please enter the number of processes: ";
    cin >> n;
    schedule(n);
    return 0;
}

这个程序会首先生成n个进程，每个进程的优先数、到达时间、需要运行时间和已用CPU时间都是随机生成的。然后按照到达时间将它们插入就绪队列中。程序会打印每个进程的PCB和初始状态（时间0时的运行进程和就绪队列）。然后程序会进入调度循环，每次循环会判断是否所有进程都已完成，是否有新进程到达，选择下一个进程运行，打印状态，判断进程是否完成，以及时间片加1。当所有进程都已完成时，程序结束。

这个程序只是一个可能的实现，还有很多需要改进的地方，比如可以加入时间片轮转算法、多级反馈队列调度算法等等。