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

#define N 5  // 进程数量

// 进程状态
char *state_str[] = {"就绪", "运行", "完成"};

// 进程控制块 PCB
struct PCB {
    char name[20];      // 进程名
    int prio;           // 优先级（动态）
    int needtime;       // 需要运行时间
    int runtime;        // 已运行时间
    char state[10];     // 状态
} pcb[N];

// 初始化进程信息
void input() {
    printf("请输入%d个进程的信息（进程名 优先级 需要时间）：\n", N);
    for (int i = 0; i < N; i++) {
        printf("进程%d: ", i + 1);
        scanf("%s %d %d", pcb[i].name, &pcb[i].prio, &pcb[i].needtime);
        pcb[i].runtime = 0;
        strcpy(pcb[i].state, "就绪");
    }
}

// 按优先级降序排序（冒泡排序）
void sort_prio() {
    struct PCB temp;
    for (int i = 0; i < N - 1; i++) {
        for (int j = i + 1; j < N; j++) {
            // 优先级高的排在前面
            if (pcb[i].prio < pcb[j].prio) {
                temp = pcb[i];
                pcb[i] = pcb[j];
                pcb[j] = temp;
            }
        }
    }
}

// 显示进程信息
void show() {
    printf("\n进程名\t优先级\t需要时间\t已运行时间\t状态\n");
    for (int i = 0; i < N; i++) {
        printf("%s\t%d\t%d\t\t%d\t\t%s\n",
               pcb[i].name,
               pcb[i].prio,
               pcb[i].needtime,
               pcb[i].runtime,
               pcb[i].state);
    }
}

// 调度算法
void schedule() {
    int count = N;  // 剩余未完成的进程数
    
    printf("\n========== 开始进程调度 ==========\n");
    
    while (count > 0) {
        // 每次调度前按优先级排序
        sort_prio();
        
        // 找到第一个未完成的进程（优先级最高）
        int idx = -1;
        for (int i = 0; i < N; i++) {
            if (strcmp(pcb[i].state, "完成") != 0) {
                idx = i;
                break;
            }
        }
        
        if (idx == -1) break;  // 所有进程都已完成
        
        // 将该进程设为运行态
        strcpy(pcb[idx].state, "运行");
        
        printf("\n>>> 当前调度进程: %s (优先级: %d, 还需时间: %d)\n", 
               pcb[idx].name, pcb[idx].prio, pcb[idx].needtime - pcb[idx].runtime);
        
        show();
        
        // 运行一个时间片
        pcb[idx].runtime++;
        
        // 动态优先级调整：运行一次后优先级减1
        pcb[idx].prio--;
        
        // 检查是否完成
        if (pcb[idx].runtime >= pcb[idx].needtime) {
            strcpy(pcb[idx].state, "完成");
            printf(">>> 进程 %s 已完成！\n", pcb[idx].name);
            count--;
        } else {
            strcpy(pcb[idx].state, "就绪");
        }
    }
    
    printf("\n========== 所有进程调度完成 ==========\n");
    show();
}

int main() {
    printf("===== 最高优先数优先调度算法 =====\n");
    printf("（动态优先级：每运行一次优先级减1）\n\n");
    
    input();
    
    printf("\n初始进程状态：");
    show();
    
    schedule();
    
    return 0;
}