请你用C语言写出一个动态优先级抢占式调度算法，包括平均周转时间和平均带权周转时间的计算，输入要有进程到达时间和服务时间

好的，以下是动态优先级抢占式调度算法的C语言实现，同时计算平均周转时间和平均带权周转时间：

#include <stdio.h>
#include <stdlib.h>

#define MAX_PROCESS 100

struct Process {
    int at; // 到达时间
    int bt; // 服务时间
    int rt; // 剩余时间
    int priority; // 优先级
    int ct; // 完成时间
    int tat; // 周转时间
    float wt; // 带权周转时间
};

int main() {
    int n, tq, time = 0;
    float avg_tat = 0, avg_wt = 0;
    struct Process p[MAX_PROCESS];

    printf("请输入进程总数：");
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        printf("请输入第%d个进程的到达时间和服务时间：", i+1);
        scanf("%d %d", &p[i].at, &p[i].bt);
        p[i].rt = p[i].bt;
        p[i].priority = 0;
        p[i].ct = 0;
        p[i].tat = 0;
        p[i].wt = 0;
    }

    printf("请输入时间片大小：");
    scanf("%d", &tq);

    while (1) {
        int flag = 1;
        for (int i = 0; i < n; i++) {
            if (p[i].rt > 0 && p[i].at <= time) {
                flag = 0;
                p[i].priority += 1;
                p[i].rt -= tq;
                if (p[i].rt <= 0) {
                    p[i].ct = time + p[i].bt - p[i].rt;
                    p[i].tat = p[i].ct - p[i].at;
                    p[i].wt = (float) p[i].tat / p[i].bt;
                    avg_tat += p[i].tat;
                    avg_wt += p[i].wt;
                }
            }
        }
        if (flag) break;
        int max_priority = -1, max_priority_index = -1;
        for (int i = 0; i < n; i++) {
            if (p[i].rt > 0 && p[i].at <= time) {
                if (p[i].priority > max_priority) {
                    max_priority = p[i].priority;
                    max_priority_index = i;
                }
            }
        }
        time += tq;
        p[max_priority_index].priority -= 1;
    }

    avg_tat /= n;
    avg_wt /= n;
    printf("平均周转时间：%.2f\n", avg_tat);
    printf("平均带权周转时间：%.2f\n", avg_wt);

    return 0;
}

在此程序中，我们使用结构体来保存每个进程的到达时间、服务时间、优先级、剩余时间、完成时间、周转时间和带权周转时间等信息。

程序流程如下：

1. 首先输入进程总数、每个进程的到达时间和服务时间，同时初始化其他信息。
2. 然后输入时间片大小。
3. 进入一个循环，直到所有进程都完成服务。
4. 在循环中，首先对于所有到达时间小于当前时间且剩余时间大于0的进程，将它们的优先级加1，同时减去一个时间片的服务时间，并更新它们的剩余时间。
5. 如果所有到达时间小于当前时间且剩余时间大于0的进程都已经完成服务，则跳出循环。
6. 否则，在所有到达时间小于当前时间且剩余时间大于0的进程中，找到优先级最高的进程，将其完成服务，并计算出它的完成时间、周转时间和带权周转时间，并累加到总数中。
7. 继续循环，直到所有进程都完成服务。
8. 最后，根据累加的周转时间和带权周转时间，计算出平均周转时间和平均带权周转时间，并输出结果。

注意，在时间片大小为1的情况下，该算法就是最高响应比优先调度算法。